| 1. // $ANTLR 2.7.7 (20060930): "CppParser4Java.g" -> "CPPParser.java"$
2.
3. /*REMOVE_BEGIN*/
4. package org.argouml.language.cpp.reveng;
5. /*REMOVE_END*/
6.
7. import java.util.Hashtable;
8. import java.util.List;
9. import java.util.ArrayList;
10.
11. import antlr.TokenBuffer;
12. import antlr.TokenStreamException;
13. import antlr.TokenStreamIOException;
14. import antlr.ANTLRException;
15. import antlr.LLkParser;
16. import antlr.Token;
17. import antlr.TokenStream;
18. import antlr.RecognitionException;
19. import antlr.NoViableAltException;
20. import antlr.MismatchedTokenException;
21. import antlr.SemanticException;
22. import antlr.ParserSharedInputState;
23. import antlr.collections.impl.BitSet;
24.
25. public class CPPParser extends antlr.LLkParser implements STDCTokenTypes
26. {
27.
28.
29. private Modeler m;
30.
31. String enclosingClass="";//name of current class
32. boolean _td=false; // is type declaration?
33. Hashtable symbols=new Hashtable();
34.
35.
36. public boolean qualifiedItemIsOneOf(java.util.BitSet qiFlags, int lookahead_offset) throws TokenSt... 37. {
38. java.util.BitSet qi = qualifiedItemIs(lookahead_offset);
39. java.util.BitSet aux=(java.util.BitSet) qi.clone();
40. aux.and(qiFlags);
41. return (!aux.isEmpty());
42. }
43.
44.
45. // This is an important function, but will be replaced with
46. // an enhanced predicate in the future, once predicates
47. // and/or predicate guards can contain loops.
48. //
49. // Scan past the ::T::B:: to see what lies beyond.
50. // Return QI_TYPE if the qualified item can pose as type name.
51. // Note that T::T is NOT a type; it is a constructor. Also,
52. // class T { ... T...} yields the enclosed T as a ctor. This
53. // is probably a type as I separate out the constructor defs/decls,
54. // I want it consistent with T::T.
55. //
56. // In the below examples, I use A,B,T and example types, and
57. // a,b as example ids.
58. // In the below examples, any A or B may be a
59. // qualified template, i.e., A<...>
60. //
61. // T::T outside of class T yields QI_CTOR.
62. // T<...>::T outside of class T yields QI_CTOR.
63. // T inside of class T {...} yields QI_CTOR.
64. // T, ::T, A::T outside of class T yields QI_TYPE.
65. // a, ::a, A::B::a yields qiId
66. // a::b yields QI_INVALID
67. // ::operator, operator, A::B::operator yield qiOPerator
68. // A::*, A::B::* yield QI_PTR_MEMBER
69. // ::*, * yields QI_INVALID
70. // ::~T, ~T, A::~T yield QI_DTOR
71. // ~a, ~A::a, A::~T::, ~T:: yield QI_INVALID
72. public java.util.BitSet qualifiedItemIs(int lookahead_offset) throws TokenStreamException
73. {
74. int value;
75. int k = lookahead_offset + 1;
76. int final_type_idx = 0;
77. boolean scope_found = false;
78. // Skip leading "::"
79. if (LT(k).getType() == SCOPE)
80. {
81. k++;
82. scope_found = true;
83. }
84. // Skip sequences of T:: or T<...>::
85. //printf("support.cpp qualifiedItemIs while reached k %d type %d isType %d, isClass %d, guessing %... 86. // k,LT(k)->getType(),isTypeName((LT(k)->getText()).data()),isClassName((LT(k)->getText()).data())... 87. while ((LT(k).getType() == ID) && (isTypeName(LT(k).getText())))
88. {// If this type is the same as the last type, then ctor
89. if ((final_type_idx != 0) && (LT(final_type_idx).getText().equals(LT(k).getText())))
90. {// Like T::T
91. // As an extra check, do not allow T::T::
92. if (LT(k+1).getType() == SCOPE)
93. { //printf("support.cpp qualifiedItemIs QI_INVALID returned\n");
94. return CPPvariables.QI_INVALID;
95. }
96. else
97. {//printf("support.cpp qualifiedItemIs QI_CTOR returned\n");
98. return CPPvariables.QI_CTOR;
99. }
100. }
101.
102. // Record this as the most recent type seen in the series
103. final_type_idx = k;
104.
105. //printf("support.cpp qualifiedItemIs if step reached final_type_idx %d\n",final_type_idx);
106.
107. // Skip this token
108. k++;
109.
110. // Skip over any template qualifiers <...>
111. // I believe that "T<..." cannot be anything valid but a template
112. if (LT(k).getType() == LESSTHAN)
113. {
114. value=skipTemplateQualifiers(k);
115. if (value==k)
116. {//printf("support.cpp qualifiedItemIs QI_INVALID(2) returned\n");
117. return CPPvariables.QI_INVALID;
118. }
119. else
120. k=value;
121. //printf("support.cpp qualifiedItemIs template skipped, k %d\n",k);
122. // k has been updated to token following <...>
123. }
124. if (LT(k).getType() == SCOPE)
125. // Skip the "::" and keep going
126. {
127. k++;
128. scope_found = true;
129. }
130. else
131. {// Series terminated -- last ID in the sequence was a type
132. // Return ctor if last type is in containing class
133. // We already checked for T::T inside loop
134. if ( enclosingClass.equals(LT(final_type_idx).getText()))
135. { // Like class T T()
136. //printf("support.cpp qualifiedItemIs QI_CTOR(2) returned\n");
137. return CPPvariables.QI_CTOR;
138. }
139. else
140. {//printf("support.cpp qualifiedItemIs QI_TYPE returned\n");
141. return CPPvariables.QI_TYPE;
142. }
143. }
144. }
145. // LT(k) is not an ID, or it is an ID but not a typename.
146. //printf("support.cpp qualifiedItemIs second switch reached\n");
147. switch (LT(k).getType())
148. {
149. case ID:
150. // ID but not a typename
151. // Do not allow id::
152. if (LT(k+1).getType() == SCOPE)
153. {
154. //printf("support.cpp qualifiedItemIs QI_INVALID(3) returned\n");
155. return CPPvariables.QI_INVALID;
156. }
157. if (enclosingClass.equals(LT(k).getText()))
158. { // Like class T T()
159. //printf("support.cpp qualifiedItemIs QI_CTOR(3) returned\n");
160. return CPPvariables.QI_CTOR;
161. }
162. else
163. {
164. if (scope_found)
165. // DW 25/10/03 Assume type if at least one SCOPE present (test12.i)
166. return CPPvariables.QI_TYPE;
167. else
168. //printf("support.cpp qualifiedItemIs QI_VAR returned\n");
169. return CPPvariables.QI_VAR; // DW 19/03/04 was QI_ID Could be function?
170. }
171. case TILDE:
172. // check for dtor
173. if ((LT(k+1).getType() == ID) && (isTypeName(LT(k+1).getText())) &&(LT(k+2).getType() != SCOPE))... 174. { // Like ~B or A::B::~B
175. // Also (incorrectly?) matches ::~A.
176. //printf("support.cpp qualifiedItemIs QI_DTOR returned\n");
177. return CPPvariables.QI_DTOR;
178. }
179. else
180. { // ~a or ~A::a is QI_INVALID
181. //printf("support.cpp qualifiedItemIs QI_INVALID(4) returned\n");
182. return CPPvariables.QI_INVALID;
183. }
184. case STAR:
185. // Like A::*
186. // Do not allow * or ::*
187. if (final_type_idx == 0)
188. { // Haven't seen a type yet
189. //printf("support.cpp qualifiedItemIs QI_INVALID(5) returned\n");
190. return CPPvariables.QI_INVALID;
191. }
192. else
193. { //printf("support.cpp qualifiedItemIs QI_PTR_MEMBER returned\n");
194. return CPPvariables.QI_PTR_MEMBER;
195. }
196. case OPERATOR:
197. // Like A::operator, ::operator, or operator
198. //printf("support.cpp qualifiedItemIs QI_OPERATOR returned\n");
199. return CPPvariables.QI_OPERATOR;
200. default:
201. // Something that neither starts with :: or ID, or
202. // a :: not followed by ID, operator, ~, or *
203. //printf("support.cpp qualifiedItemIs QI_INVALID(6) returned\n");
204. return CPPvariables.QI_INVALID;
205. }
206. }
207.
208. // Skip over <...>. This correctly handles nested <> and (), e.g:
209. // <T>
210. // < (i>3) >
211. // < T2<...> >
212. // but not
213. // < i>3 >
214. //
215. // On input, kInOut is the index of the "<"
216. // On output, if the return is true, then
217. // kInOut is the index of the token after ">"
218. // else
219. // kInOut is unchanged
220.
221. public int skipTemplateQualifiers(int kInOut) throws TokenStreamException
222. {
223. // Start after "<"
224. int k = kInOut + 1;
225. int value;
226. while (LT(k).getType() != GREATERTHAN) // scan to end of <...>
227. {
228. switch (LT(k).getType())
229. {
230. case EOF:
231. return kInOut;
232. case LESSTHAN:
233. value=skipTemplateQualifiers(k);
234. if (value==k)
235. {
236. return kInOut;
237. }
238. else
239. k=value;
240. break;
241. case LPAREN:
242. value=skipNestedParens(k);
243. if (value==k)
244. {
245. return kInOut;
246. }
247. else
248. k=value;
249. break;
250. default:
251. k++; // skip everything else
252. break;
253. }
254. if (k > CPPvariables.MAX_TEMPLATE_TOKEN_SCAN)
255. {
256. return kInOut;
257. }
258. }
259.
260. // Update output argument to point past ">"
261. kInOut = k + 1;
262. return kInOut;
263. }
264.
265. // Skip over (...). This correctly handles nested (), e.g:
266. // (i>3, (i>5))
267. //
268. // On input, kInOut is the index of the "("
269. // On output, if the return is true, then
270. // kInOut is the index of the token after ")"
271. // else
272. // kInOut is unchanged
273. public int skipNestedParens(int kInOut) throws TokenStreamException
274. {
275. // Start after "("
276. int k = kInOut + 1;
277. int value;
278. while (LT(k).getType() != RPAREN) // scan to end of (...)
279. {
280. switch (LT(k).getType())
281. {
282. case EOF:
283. return kInOut;
284. case LPAREN:
285. value=skipNestedParens(k);
286. if (value==k)
287. {
288. return kInOut;
289. }
290. else
291. k=value;
292. break;
293. default:
294. k++; // skip everything else
295. break;
296. }
297. if (k > CPPvariables.MAX_TEMPLATE_TOKEN_SCAN)
298. {
299. return kInOut;
300. }
301. }
302. // Update output argument to point past ")"
303. kInOut = k + 1;
304. return kInOut;
305. }
306.
307. // Return true if "::blah" or "fu::bar<args>::..." found.
308. public boolean scopedItem(int k) throws TokenStreamException
309. {
310. //printf("support.cpp scopedItem k %d\n",k);
311. return (LT(k).getType()==SCOPE ||
312. (LT(k).getType()==ID && !finalQualifier(k)));
313. }
314.
315. // Return true if ID<...> or ID is last item in qualified item list.
316. // Return false if LT(k) is not an ID.
317. // ID must be a type to check for ID<...>,
318. // or else we would get confused by "i<3"
319. public boolean finalQualifier(int k) throws TokenStreamException
320. {
321. if (LT(k).getType()==ID)
322. {
323. if ((isTypeName(LT(k).getText())) && (LT(k+1).getType()==LESSTHAN))
324. {
325. // Starts with "T<". Skip <...>
326. k++;
327. k=skipTemplateQualifiers(k);
328. }
329. else
330. {
331. // skip ID;
332. k++;
333. }
334. return (LT(k).getType() != SCOPE );
335. }
336. else
337. { // not an ID
338. return false;
339. }
340. }
341.
342. /*
343. * Return true if 's' can pose as a type name
344. */
345. public boolean isTypeName(String s)
346. {
347. String type="";
348. if (!symbols.containsKey(s))
349. {
350. //printf("support.cpp isTypeName %s not found\n",s);
351. return false;
352. }
353. else
354. type=(String) symbols.get(s);
355. if (type.equals(CPPvariables.OT_TYPE_DEF)||
356. type.equals(CPPvariables.OT_ENUM)||
357. type.equals(CPPvariables.OT_CLASS)||
358. type.equals(CPPvariables.OT_STRUCT)||
359. type.equals(CPPvariables.OT_UNION))
360. {
361. return true;
362. }
363. return false;
364. }
365.
366. public void declaratorID(String id, java.util.BitSet qi)
367. {
368. if ((qi.equals(CPPvariables.QI_TYPE)) || (_td)) // Check for type declaration
369. {
370. if (!symbols.containsKey(id))
371. symbols.put(id, CPPvariables.OT_TYPE_DEF);
372. }
373. }
374.
375. protected CPPParser(TokenBuffer tokenBuf, int k) {
376. super(tokenBuf,k);
377. tokenNames = _tokenNames;
378. }
379.
380. public CPPParser(TokenBuffer tokenBuf) {
381. this(tokenBuf,2);
382. }
383.
384. protected CPPParser(TokenStream lexer, int k) {
385. super(lexer,k);
386. tokenNames = _tokenNames;
387. }
388.
389. public CPPParser(TokenStream lexer) {
390. this(lexer,2);
391. }
392.
393. public CPPParser(ParserSharedInputState state) {
394. super(state,2);
395. tokenNames = _tokenNames;
396. }
397.
398. public final void translation_unit(
399. Modeler modeler
400. ) throws RecognitionException, TokenStreamException {
401.
402.
403. if(!symbols.containsKey("std"))
404. symbols.put("std",CPPvariables.OT_TYPE_DEF);
405. m = modeler;
406.
407.
408. if ( inputState.guessing==0 ) {
409. m.beginTranslationUnit();
410. }
411. {
412. int _cnt3=0;
413. _loop3:
414. do {
415. if ((_tokenSet_0.member(LA(1)))) {
416. external_declaration();
417. }
418. else {
419. if ( _cnt3>=1 ) { break _loop3; } else {throw new NoViableAltException(LT(1), getFilename());}
420. }
421.
422. _cnt3++;
423. } while (true);
424. }
425. match(Token.EOF_TYPE);
426. if ( inputState.guessing==0 ) {
427. m.endTranslationUnit();
428. }
429. }
430.
431. public final void external_declaration() throws RecognitionException, TokenStreamException {
432.
433. String s="";
434.
435. {
436. switch ( LA(1)) {
437. case LITERAL_namespace:
438. {
439. decl_namespace();
440. break;
441. }
442. case SEMICOLON:
443. {
444. match(SEMICOLON);
445. break;
446. }
447. default:
448. boolean synPredMatched7 = false;
449. if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
450. int _m7 = mark();
451. synPredMatched7 = true;
452. inputState.guessing++;
453. try {
454. {
455. match(LITERAL_template);
456. match(LESSTHAN);
457. match(GREATERTHAN);
458. }
459. }
460. catch (RecognitionException pe) {
461. synPredMatched7 = false;
462. }
463. rewind(_m7);
464. inputState.guessing--;
465. }
466. if ( synPredMatched7 ) {
467. match(LITERAL_template);
468. match(LESSTHAN);
469. match(GREATERTHAN);
470. declaration();
471. }
472. else {
473. boolean synPredMatched10 = false;
474. if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
475. int _m10 = mark();
476. synPredMatched10 = true;
477. inputState.guessing++;
478. try {
479. {
480. {
481. switch ( LA(1)) {
482. case LITERAL_typedef:
483. {
484. match(LITERAL_typedef);
485. break;
486. }
487. case LITERAL_class:
488. case LITERAL_struct:
489. case LITERAL_union:
490. {
491. break;
492. }
493. default:
494. {
495. throw new NoViableAltException(LT(1), getFilename());
496. }
497. }
498. }
499. class_head();
500. }
501. }
502. catch (RecognitionException pe) {
503. synPredMatched10 = false;
504. }
505. rewind(_m10);
506. inputState.guessing--;
507. }
508. if ( synPredMatched10 ) {
509. declaration();
510. }
511. else {
512. boolean synPredMatched12 = false;
513. if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
514. int _m12 = mark();
515. synPredMatched12 = true;
516. inputState.guessing++;
517. try {
518. {
519. template_head();
520. class_head();
521. }
522. }
523. catch (RecognitionException pe) {
524. synPredMatched12 = false;
525. }
526. rewind(_m12);
527. inputState.guessing--;
528. }
529. if ( synPredMatched12 ) {
530. template_head();
531. declaration();
532. }
533. else {
534. boolean synPredMatched15 = false;
535. if (((LA(1)==LITERAL_enum) && (LA(2)==ID||LA(2)==LCURLY))) {
536. int _m15 = mark();
537. synPredMatched15 = true;
538. inputState.guessing++;
539. try {
540. {
541. match(LITERAL_enum);
542. {
543. switch ( LA(1)) {
544. case ID:
545. {
546. match(ID);
547. break;
548. }
549. case LCURLY:
550. {
551. break;
552. }
553. default:
554. {
555. throw new NoViableAltException(LT(1), getFilename());
556. }
557. }
558. }
559. match(LCURLY);
560. }
561. }
562. catch (RecognitionException pe) {
563. synPredMatched15 = false;
564. }
565. rewind(_m15);
566. inputState.guessing--;
567. }
568. if ( synPredMatched15 ) {
569. enum_specifier();
570. {
571. switch ( LA(1)) {
572. case ID:
573. case LITERAL__stdcall:
574. case LITERAL___stdcall:
575. case LPAREN:
576. case OPERATOR:
577. case LITERAL_this:
578. case LITERAL_true:
579. case LITERAL_false:
580. case STAR:
581. case AMPERSAND:
582. case TILDE:
583. case SCOPE:
584. case LITERAL__cdecl:
585. case LITERAL___cdecl:
586. case LITERAL__near:
587. case LITERAL___near:
588. case LITERAL__far:
589. case LITERAL___far:
590. case LITERAL___interrupt:
591. case LITERAL_pascal:
592. case LITERAL__pascal:
593. case LITERAL___pascal:
594. {
595. init_declarator_list();
596. break;
597. }
598. case SEMICOLON:
599. {
600. break;
601. }
602. default:
603. {
604. throw new NoViableAltException(LT(1), getFilename());
605. }
606. }
607. }
608. match(SEMICOLON);
609. }
610. else {
611. boolean synPredMatched19 = false;
612. if (((_tokenSet_3.member(LA(1))) && (_tokenSet_4.member(LA(2))))) {
613. int _m19 = mark();
614. synPredMatched19 = true;
615. inputState.guessing++;
616. try {
617. {
618. {
619. switch ( LA(1)) {
620. case LITERAL_template:
621. {
622. template_head();
623. break;
624. }
625. case ID:
626. case LITERAL_inline:
627. case LITERAL__inline:
628. case LITERAL___inline:
629. case LITERAL_virtual:
630. case TILDE:
631. case SCOPE:
632. {
633. break;
634. }
635. default:
636. {
637. throw new NoViableAltException(LT(1), getFilename());
638. }
639. }
640. }
641. dtor_head();
642. match(LCURLY);
643. }
644. }
645. catch (RecognitionException pe) {
646. synPredMatched19 = false;
647. }
648. rewind(_m19);
649. inputState.guessing--;
650. }
651. if ( synPredMatched19 ) {
652. {
653. switch ( LA(1)) {
654. case LITERAL_template:
655. {
656. template_head();
657. break;
658. }
659. case ID:
660. case LITERAL_inline:
661. case LITERAL__inline:
662. case LITERAL___inline:
663. case LITERAL_virtual:
664. case TILDE:
665. case SCOPE:
666. {
667. break;
668. }
669. default:
670. {
671. throw new NoViableAltException(LT(1), getFilename());
672. }
673. }
674. }
675. dtor_head();
676. dtor_body();
677. }
678. else {
679. boolean synPredMatched23 = false;
680. if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
681. int _m23 = mark();
682. synPredMatched23 = true;
683. inputState.guessing++;
684. try {
685. {
686. {
687. if ((true) && (true)) {
688. ctor_decl_spec();
689. }
690. else {
691. }
692.
693. }
694. if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
695. throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
696. }
697. }
698. catch (RecognitionException pe) {
699. synPredMatched23 = false;
700. }
701. rewind(_m23);
702. inputState.guessing--;
703. }
704. if ( synPredMatched23 ) {
705. ctor_definition();
706. }
707. else {
708. boolean synPredMatched26 = false;
709. if (((_tokenSet_7.member(LA(1))) && (_tokenSet_8.member(LA(2))))) {
710. int _m26 = mark();
711. synPredMatched26 = true;
712. inputState.guessing++;
713. try {
714. {
715. {
716. switch ( LA(1)) {
717. case LITERAL_inline:
718. {
719. match(LITERAL_inline);
720. break;
721. }
722. case ID:
723. case OPERATOR:
724. case SCOPE:
725. {
726. break;
727. }
728. default:
729. {
730. throw new NoViableAltException(LT(1), getFilename());
731. }
732. }
733. }
734. scope_override();
735. conversion_function_decl_or_def();
736. }
737. }
738. catch (RecognitionException pe) {
739. synPredMatched26 = false;
740. }
741. rewind(_m26);
742. inputState.guessing--;
743. }
744. if ( synPredMatched26 ) {
745. {
746. switch ( LA(1)) {
747. case LITERAL_inline:
748. {
749. match(LITERAL_inline);
750. break;
751. }
752. case ID:
753. case OPERATOR:
754. case SCOPE:
755. {
756. break;
757. }
758. default:
759. {
760. throw new NoViableAltException(LT(1), getFilename());
761. }
762. }
763. }
764. s=scope_override();
765. conversion_function_decl_or_def();
766. }
767. else {
768. boolean synPredMatched29 = false;
769. if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
770. int _m29 = mark();
771. synPredMatched29 = true;
772. inputState.guessing++;
773. try {
774. {
775. declaration_specifiers();
776. function_declarator();
777. match(SEMICOLON);
778. }
779. }
780. catch (RecognitionException pe) {
781. synPredMatched29 = false;
782. }
783. rewind(_m29);
784. inputState.guessing--;
785. }
786. if ( synPredMatched29 ) {
787. declaration();
788. }
789. else {
790. boolean synPredMatched31 = false;
791. if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
792. int _m31 = mark();
793. synPredMatched31 = true;
794. inputState.guessing++;
795. try {
796. {
797. declaration_specifiers();
798. function_declarator();
799. match(LCURLY);
800. }
801. }
802. catch (RecognitionException pe) {
803. synPredMatched31 = false;
804. }
805. rewind(_m31);
806. inputState.guessing--;
807. }
808. if ( synPredMatched31 ) {
809. if ( inputState.guessing==0 ) {
810. m.beginFunctionDefinition();
811. }
812. function_definition();
813. if ( inputState.guessing==0 ) {
814. m.endFunctionDefinition();
815. }
816. }
817. else {
818. boolean synPredMatched33 = false;
819. if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
820. int _m33 = mark();
821. synPredMatched33 = true;
822. inputState.guessing++;
823. try {
824. {
825. declaration_specifiers();
826. function_declarator();
827. declaration();
828. }
829. }
830. catch (RecognitionException pe) {
831. synPredMatched33 = false;
832. }
833. rewind(_m33);
834. inputState.guessing--;
835. }
836. if ( synPredMatched33 ) {
837. function_definition();
838. }
839. else {
840. boolean synPredMatched36 = false;
841. if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
842. int _m36 = mark();
843. synPredMatched36 = true;
844. inputState.guessing++;
845. try {
846. {
847. template_head();
848. declaration_specifiers();
849. {
850. switch ( LA(1)) {
851. case ID:
852. case LITERAL__stdcall:
853. case LITERAL___stdcall:
854. case LPAREN:
855. case OPERATOR:
856. case LITERAL_this:
857. case LITERAL_true:
858. case LITERAL_false:
859. case STAR:
860. case AMPERSAND:
861. case TILDE:
862. case SCOPE:
863. case LITERAL__cdecl:
864. case LITERAL___cdecl:
865. case LITERAL__near:
866. case LITERAL___near:
867. case LITERAL__far:
868. case LITERAL___far:
869. case LITERAL___interrupt:
870. case LITERAL_pascal:
871. case LITERAL__pascal:
872. case LITERAL___pascal:
873. {
874. init_declarator_list();
875. break;
876. }
877. case SEMICOLON:
878. {
879. break;
880. }
881. default:
882. {
883. throw new NoViableAltException(LT(1), getFilename());
884. }
885. }
886. }
887. match(SEMICOLON);
888. }
889. }
890. catch (RecognitionException pe) {
891. synPredMatched36 = false;
892. }
893. rewind(_m36);
894. inputState.guessing--;
895. }
896. if ( synPredMatched36 ) {
897. template_head();
898. declaration_specifiers();
899. {
900. switch ( LA(1)) {
901. case ID:
902. case LITERAL__stdcall:
903. case LITERAL___stdcall:
904. case LPAREN:
905. case OPERATOR:
906. case LITERAL_this:
907. case LITERAL_true:
908. case LITERAL_false:
909. case STAR:
910. case AMPERSAND:
911. case TILDE:
912. case SCOPE:
913. case LITERAL__cdecl:
914. case LITERAL___cdecl:
915. case LITERAL__near:
916. case LITERAL___near:
917. case LITERAL__far:
918. case LITERAL___far:
919. case LITERAL___interrupt:
920. case LITERAL_pascal:
921. case LITERAL__pascal:
922. case LITERAL___pascal:
923. {
924. init_declarator_list();
925. break;
926. }
927. case SEMICOLON:
928. {
929. break;
930. }
931. default:
932. {
933. throw new NoViableAltException(LT(1), getFilename());
934. }
935. }
936. }
937. match(SEMICOLON);
938. }
939. else if ((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN)) {
940. template_head();
941. {
942. boolean synPredMatched40 = false;
943. if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
944. int _m40 = mark();
945. synPredMatched40 = true;
946. inputState.guessing++;
947. try {
948. {
949. ctor_decl_spec();
950. if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
951. throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
952. }
953. }
954. catch (RecognitionException pe) {
955. synPredMatched40 = false;
956. }
957. rewind(_m40);
958. inputState.guessing--;
959. }
960. if ( synPredMatched40 ) {
961. ctor_definition();
962. }
963. else {
964. boolean synPredMatched42 = false;
965. if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
966. int _m42 = mark();
967. synPredMatched42 = true;
968. inputState.guessing++;
969. try {
970. {
971. declaration_specifiers();
972. function_declarator();
973. match(SEMICOLON);
974. }
975. }
976. catch (RecognitionException pe) {
977. synPredMatched42 = false;
978. }
979. rewind(_m42);
980. inputState.guessing--;
981. }
982. if ( synPredMatched42 ) {
983. declaration();
984. }
985. else {
986. boolean synPredMatched44 = false;
987. if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
988. int _m44 = mark();
989. synPredMatched44 = true;
990. inputState.guessing++;
991. try {
992. {
993. declaration_specifiers();
994. function_declarator();
995. match(LCURLY);
996. }
997. }
998. catch (RecognitionException pe) {
999. synPredMatched44 = false;
1000. }
1001. rewind(_m44);
1002. inputState.guessing--;
1003. }
1004. if ( synPredMatched44 ) {
1005. function_definition();
1006. }
1007. else {
1008. throw new NoViableAltException(LT(1), getFilename());
1009. }
1010. }}
1011. }
1012. }
1013. else if ((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2)))) {
1014. declaration();
1015. }
1016. else {
1017. throw new NoViableAltException(LT(1), getFilename());
1018. }
1019. }}}}}}}}}}}
1020. }
1021. }
1022.
1023. public final void declaration() throws RecognitionException, TokenStreamException {
1024.
1025.
1026. boolean synPredMatched106 = false;
1027. if (((LA(1)==LITERAL_extern) && (LA(2)==StringLiteral))) {
1028. int _m106 = mark();
1029. synPredMatched106 = true;
1030. inputState.guessing++;
1031. try {
1032. {
1033. match(LITERAL_extern);
1034. match(StringLiteral);
1035. }
1036. }
1037. catch (RecognitionException pe) {
1038. synPredMatched106 = false;
1039. }
1040. rewind(_m106);
1041. inputState.guessing--;
1042. }
1043. if ( synPredMatched106 ) {
1044. linkage_specification();
1045. }
1046. else if ((_tokenSet_11.member(LA(1))) && (_tokenSet_12.member(LA(2)))) {
1047. declaration_specifiers();
1048. {
1049. switch ( LA(1)) {
1050. case ID:
1051. case COMMA:
1052. case LITERAL__stdcall:
1053. case LITERAL___stdcall:
1054. case LPAREN:
1055. case OPERATOR:
1056. case LITERAL_this:
1057. case LITERAL_true:
1058. case LITERAL_false:
1059. case STAR:
1060. case AMPERSAND:
1061. case TILDE:
1062. case SCOPE:
1063. case LITERAL__cdecl:
1064. case LITERAL___cdecl:
1065. case LITERAL__near:
1066. case LITERAL___near:
1067. case LITERAL__far:
1068. case LITERAL___far:
1069. case LITERAL___interrupt:
1070. case LITERAL_pascal:
1071. case LITERAL__pascal:
1072. case LITERAL___pascal:
1073. {
1074. {
1075. switch ( LA(1)) {
1076. case COMMA:
1077. {
1078. match(COMMA);
1079. break;
1080. }
1081. case ID:
1082. case LITERAL__stdcall:
1083. case LITERAL___stdcall:
1084. case LPAREN:
1085. case OPERATOR:
1086. case LITERAL_this:
1087. case LITERAL_true:
1088. case LITERAL_false:
1089. case STAR:
1090. case AMPERSAND:
1091. case TILDE:
1092. case SCOPE:
1093. case LITERAL__cdecl:
1094. case LITERAL___cdecl:
1095. case LITERAL__near:
1096. case LITERAL___near:
1097. case LITERAL__far:
1098. case LITERAL___far:
1099. case LITERAL___interrupt:
1100. case LITERAL_pascal:
1101. case LITERAL__pascal:
1102. case LITERAL___pascal:
1103. {
1104. break;
1105. }
1106. default:
1107. {
1108. throw new NoViableAltException(LT(1), getFilename());
1109. }
1110. }
1111. }
1112. init_declarator_list();
1113. break;
1114. }
1115. case SEMICOLON:
1116. {
1117. break;
1118. }
1119. default:
1120. {
1121. throw new NoViableAltException(LT(1), getFilename());
1122. }
1123. }
1124. }
1125. match(SEMICOLON);
1126. }
1127. else if ((LA(1)==LITERAL_using)) {
1128. using_declaration();
1129. }
1130. else {
1131. throw new NoViableAltException(LT(1), getFilename());
1132. }
1133.
1134. }
1135.
1136. public final void class_head() throws RecognitionException, TokenStreamException {
1137.
1138.
1139. {
1140. switch ( LA(1)) {
1141. case LITERAL_struct:
1142. {
1143. match(LITERAL_struct);
1144. break;
1145. }
1146. case LITERAL_union:
1147. {
1148. match(LITERAL_union);
1149. break;
1150. }
1151. case LITERAL_class:
1152. {
1153. match(LITERAL_class);
1154. break;
1155. }
1156. default:
1157. {
1158. throw new NoViableAltException(LT(1), getFilename());
1159. }
1160. }
1161. }
1162. {
1163. switch ( LA(1)) {
1164. case ID:
1165. {
1166. match(ID);
1167. {
1168. switch ( LA(1)) {
1169. case LESSTHAN:
1170. {
1171. match(LESSTHAN);
1172. template_argument_list();
1173. match(GREATERTHAN);
1174. break;
1175. }
1176. case LCURLY:
1177. case COLON:
1178. {
1179. break;
1180. }
1181. default:
1182. {
1183. throw new NoViableAltException(LT(1), getFilename());
1184. }
1185. }
1186. }
1187. {
1188. switch ( LA(1)) {
1189. case COLON:
1190. {
1191. base_clause();
1192. break;
1193. }
1194. case LCURLY:
1195. {
1196. break;
1197. }
1198. default:
1199. {
1200. throw new NoViableAltException(LT(1), getFilename());
1201. }
1202. }
1203. }
1204. break;
1205. }
1206. case LCURLY:
1207. {
1208. break;
1209. }
1210. default:
1211. {
1212. throw new NoViableAltException(LT(1), getFilename());
1213. }
1214. }
1215. }
1216. match(LCURLY);
1217. }
1218.
1219. public final void template_head() throws RecognitionException, TokenStreamException {
1220.
1221.
1222. match(LITERAL_template);
1223. match(LESSTHAN);
1224. template_parameter_list();
1225. match(GREATERTHAN);
1226. }
1227.
1228. public final void enum_specifier() throws RecognitionException, TokenStreamException {
1229.
1230. Token id = null;
1231.
1232. match(LITERAL_enum);
1233. {
1234. switch ( LA(1)) {
1235. case LCURLY:
1236. {
1237. match(LCURLY);
1238. enumerator_list();
1239. match(RCURLY);
1240. break;
1241. }
1242. case ID:
1243. {
1244. id = LT(1);
1245. match(ID);
1246. if ( inputState.guessing==0 ) {
1247. if(!symbols.containsKey(id.getText()))
1248. symbols.put(id.getText(),CPPvariables.OT_ENUM);
1249.
1250. }
1251. {
1252. switch ( LA(1)) {
1253. case LCURLY:
1254. {
1255. match(LCURLY);
1256. enumerator_list();
1257. match(RCURLY);
1258. break;
1259. }
1260. case LESSTHAN:
1261. case GREATERTHAN:
1262. case ID:
1263. case SEMICOLON:
1264. case RCURLY:
1265. case ASSIGNEQUAL:
1266. case COLON:
1267. case COMMA:
1268. case LITERAL__stdcall:
1269. case LITERAL___stdcall:
1270. case LPAREN:
1271. case RPAREN:
1272. case OPERATOR:
1273. case LITERAL_this:
1274. case LITERAL_true:
1275. case LITERAL_false:
1276. case STAR:
1277. case AMPERSAND:
1278. case LSQUARE:
1279. case RSQUARE:
1280. case TILDE:
1281. case ELLIPSIS:
1282. case TIMESEQUAL:
1283. case DIVIDEEQUAL:
1284. case MINUSEQUAL:
1285. case PLUSEQUAL:
1286. case MODEQUAL:
1287. case SHIFTLEFTEQUAL:
1288. case SHIFTRIGHTEQUAL:
1289. case BITWISEANDEQUAL:
1290. case BITWISEXOREQUAL:
1291. case BITWISEOREQUAL:
1292. case QUESTIONMARK:
1293. case OR:
1294. case AND:
1295. case BITWISEOR:
1296. case BITWISEXOR:
1297. case NOTEQUAL:
1298. case EQUAL:
1299. case LESSTHANOREQUALTO:
1300. case GREATERTHANOREQUALTO:
1301. case SHIFTLEFT:
1302. case SHIFTRIGHT:
1303. case PLUS:
1304. case MINUS:
1305. case DIVIDE:
1306. case MOD:
1307. case DOTMBR:
1308. case POINTERTOMBR:
1309. case SCOPE:
1310. case LITERAL__cdecl:
1311. case LITERAL___cdecl:
1312. case LITERAL__near:
1313. case LITERAL___near:
1314. case LITERAL__far:
1315. case LITERAL___far:
1316. case LITERAL___interrupt:
1317. case LITERAL_pascal:
1318. case LITERAL__pascal:
1319. case LITERAL___pascal:
1320. {
1321. break;
1322. }
1323. default:
1324. {
1325. throw new NoViableAltException(LT(1), getFilename());
1326. }
1327. }
1328. }
1329. break;
1330. }
1331. default:
1332. {
1333. throw new NoViableAltException(LT(1), getFilename());
1334. }
1335. }
1336. }
1337. }
1338.
1339. public final void init_declarator_list() throws RecognitionException, TokenStreamException {
1340.
1341.
1342. init_declarator();
1343. {
1344. _loop156:
1345. do {
1346. if ((LA(1)==COMMA)) {
1347. match(COMMA);
1348. init_declarator();
1349. }
1350. else {
1351. break _loop156;
1352. }
1353.
1354. } while (true);
1355. }
1356. }
1357.
1358. public final void dtor_head() throws RecognitionException, TokenStreamException {
1359.
1360.
1361. if ( inputState.guessing==0 ) {
1362. m.beginDtorHead();
1363. }
1364. dtor_decl_spec();
1365. dtor_declarator();
1366. if ( inputState.guessing==0 ) {
1367. m.endDtorHead();
1368. }
1369. }
1370.
1371. public final void dtor_body() throws RecognitionException, TokenStreamException {
1372.
1373.
1374. compound_statement();
1375. }
1376.
1377. public final void ctor_decl_spec() throws RecognitionException, TokenStreamException {
1378.
1379. List declSpecs = new ArrayList();
1380.
1381. {
1382. _loop240:
1383. do {
1384. switch ( LA(1)) {
1385. case LITERAL_inline:
1386. case LITERAL__inline:
1387. case LITERAL___inline:
1388. {
1389. {
1390. switch ( LA(1)) {
1391. case LITERAL_inline:
1392. {
1393. match(LITERAL_inline);
1394. break;
1395. }
1396. case LITERAL__inline:
1397. {
1398. match(LITERAL__inline);
1399. break;
1400. }
1401. case LITERAL___inline:
1402. {
1403. match(LITERAL___inline);
1404. break;
1405. }
1406. default:
1407. {
1408. throw new NoViableAltException(LT(1), getFilename());
1409. }
1410. }
1411. }
1412. if ( inputState.guessing==0 ) {
1413. declSpecs.add("inline");
1414. }
1415. break;
1416. }
1417. case LITERAL_explicit:
1418. {
1419. match(LITERAL_explicit);
1420. if ( inputState.guessing==0 ) {
1421. declSpecs.add("explicit");
1422. }
1423. break;
1424. }
1425. default:
1426. {
1427. break _loop240;
1428. }
1429. }
1430. } while (true);
1431. }
1432. if ( inputState.guessing==0 ) {
1433. m.declarationSpecifiers(declSpecs);
1434. }
1435. }
1436.
1437. public final void ctor_definition() throws RecognitionException, TokenStreamException {
1438.
1439.
1440. if ( inputState.guessing==0 ) {
1441. m.beginCtorDefinition();
1442. }
1443. ctor_head();
1444. ctor_body();
1445. if ( inputState.guessing==0 ) {
1446. m.endCtorDefinition();
1447. }
1448. }
1449.
1450. public final String scope_override() throws RecognitionException, TokenStreamException {
1451. String s="";
1452.
1453. Token id = null;
1454.
1455. String sitem="";
1456.
1457.
1458. {
1459. switch ( LA(1)) {
1460. case SCOPE:
1461. {
1462. match(SCOPE);
1463. if ( inputState.guessing==0 ) {
1464. sitem=sitem+"::";
1465. }
1466. break;
1467. }
1468. case ID:
1469. case OPERATOR:
1470. case LITERAL_this:
1471. case LITERAL_true:
1472. case LITERAL_false:
1473. case STAR:
1474. case TILDE:
1475. {
1476. break;
1477. }
1478. default:
1479. {
1480. throw new NoViableAltException(LT(1), getFilename());
1481. }
1482. }
1483. }
1484. {
1485. _loop457:
1486. do {
1487. if (((LA(1)==ID) && (LA(2)==LESSTHAN||LA(2)==SCOPE))&&(scopedItem(1))) {
1488. id = LT(1);
1489. match(ID);
1490. {
1491. switch ( LA(1)) {
1492. case LESSTHAN:
1493. {
1494. match(LESSTHAN);
1495. template_argument_list();
1496. match(GREATERTHAN);
1497. break;
1498. }
1499. case SCOPE:
1500. {
1501. break;
1502. }
1503. default:
1504. {
1505. throw new NoViableAltException(LT(1), getFilename());
1506. }
1507. }
1508. }
1509. match(SCOPE);
1510. if ( inputState.guessing==0 ) {
1511.
1512. sitem=sitem+id.getText();
1513. sitem=sitem+"::";
1514.
1515. }
1516. }
1517. else {
1518. break _loop457;
1519. }
1520.
1521. } while (true);
1522. }
1523. if ( inputState.guessing==0 ) {
1524. s = sitem;
1525. }
1526. return s;
1527. }
1528.
1529. public final void conversion_function_decl_or_def() throws RecognitionException, TokenStreamExcepti...1530.
1531.
1532. match(OPERATOR);
1533. declaration_specifiers();
1534. {
1535. switch ( LA(1)) {
1536. case STAR:
1537. {
1538. match(STAR);
1539. break;
1540. }
1541. case AMPERSAND:
1542. {
1543. match(AMPERSAND);
1544. break;
1545. }
1546. case LESSTHAN:
1547. case LPAREN:
1548. {
1549. break;
1550. }
1551. default:
1552. {
1553. throw new NoViableAltException(LT(1), getFilename());
1554. }
1555. }
1556. }
1557. {
1558. switch ( LA(1)) {
1559. case LESSTHAN:
1560. {
1561. match(LESSTHAN);
1562. template_parameter_list();
1563. match(GREATERTHAN);
1564. break;
1565. }
1566. case LPAREN:
1567. {
1568. break;
1569. }
1570. default:
1571. {
1572. throw new NoViableAltException(LT(1), getFilename());
1573. }
1574. }
1575. }
1576. match(LPAREN);
1577. {
1578. switch ( LA(1)) {
1579. case LITERAL_typedef:
1580. case LITERAL_enum:
1581. case ID:
1582. case LITERAL_inline:
1583. case LITERAL_extern:
1584. case LITERAL__inline:
1585. case LITERAL___inline:
1586. case LITERAL_virtual:
1587. case LITERAL_explicit:
1588. case LITERAL_friend:
1589. case LITERAL__stdcall:
1590. case LITERAL___stdcall:
1591. case LITERAL__declspec:
1592. case LITERAL___declspec:
1593. case LPAREN:
1594. case LITERAL_typename:
1595. case LITERAL_auto:
1596. case LITERAL_register:
1597. case LITERAL_static:
1598. case LITERAL_mutable:
1599. case LITERAL_const:
1600. case LITERAL_const_cast:
1601. case LITERAL_volatile:
1602. case LITERAL_char:
1603. case LITERAL_wchar_t:
1604. case LITERAL_bool:
1605. case LITERAL_short:
1606. case LITERAL_int:
1607. case 44:
1608. case 45:
1609. case 46:
1610. case LITERAL_long:
1611. case LITERAL_signed:
1612. case LITERAL_unsigned:
1613. case LITERAL_float:
1614. case LITERAL_double:
1615. case LITERAL_void:
1616. case LITERAL_class:
1617. case LITERAL_struct:
1618. case LITERAL_union:
1619. case OPERATOR:
1620. case LITERAL_this:
1621. case LITERAL_true:
1622. case LITERAL_false:
1623. case STAR:
1624. case AMPERSAND:
1625. case TILDE:
1626. case ELLIPSIS:
1627. case SCOPE:
1628. case LITERAL__cdecl:
1629. case LITERAL___cdecl:
1630. case LITERAL__near:
1631. case LITERAL___near:
1632. case LITERAL__far:
1633. case LITERAL___far:
1634. case LITERAL___interrupt:
1635. case LITERAL_pascal:
1636. case LITERAL__pascal:
1637. case LITERAL___pascal:
1638. {
1639. parameter_list();
1640. break;
1641. }
1642. case RPAREN:
1643. {
1644. break;
1645. }
1646. default:
1647. {
1648. throw new NoViableAltException(LT(1), getFilename());
1649. }
1650. }
1651. }
1652. match(RPAREN);
1653. {
1654. switch ( LA(1)) {
1655. case LITERAL_const:
1656. case LITERAL_const_cast:
1657. case LITERAL_volatile:
1658. {
1659. type_qualifier();
1660. break;
1661. }
1662. case LCURLY:
1663. case SEMICOLON:
1664. case LITERAL_throw:
1665. {
1666. break;
1667. }
1668. default:
1669. {
1670. throw new NoViableAltException(LT(1), getFilename());
1671. }
1672. }
1673. }
1674. {
1675. switch ( LA(1)) {
1676. case LITERAL_throw:
1677. {
1678. exception_specification();
1679. break;
1680. }
1681. case LCURLY:
1682. case SEMICOLON:
1683. {
1684. break;
1685. }
1686. default:
1687. {
1688. throw new NoViableAltException(LT(1), getFilename());
1689. }
1690. }
1691. }
1692. {
1693. switch ( LA(1)) {
1694. case LCURLY:
1695. {
1696. compound_statement();
1697. break;
1698. }
1699. case SEMICOLON:
1700. {
1701. match(SEMICOLON);
1702. break;
1703. }
1704. default:
1705. {
1706. throw new NoViableAltException(LT(1), getFilename());
1707. }
1708. }
1709. }
1710. }
1711.
1712. public final void declaration_specifiers() throws RecognitionException, TokenStreamException {
1713.
1714. _td=false; boolean td=false; List declSpecs = new ArrayList();
1715.
1716. {
1717. switch ( LA(1)) {
1718. case LITERAL_typedef:
1719. case LITERAL_enum:
1720. case ID:
1721. case LITERAL_inline:
1722. case LITERAL_extern:
1723. case LITERAL__inline:
1724. case LITERAL___inline:
1725. case LITERAL_virtual:
1726. case LITERAL_explicit:
1727. case LITERAL_friend:
1728. case LITERAL__stdcall:
1729. case LITERAL___stdcall:
1730. case LITERAL__declspec:
1731. case LITERAL___declspec:
1732. case LITERAL_auto:
1733. case LITERAL_register:
1734. case LITERAL_static:
1735. case LITERAL_mutable:
1736. case LITERAL_const:
1737. case LITERAL_const_cast:
1738. case LITERAL_volatile:
1739. case LITERAL_char:
1740. case LITERAL_wchar_t:
1741. case LITERAL_bool:
1742. case LITERAL_short:
1743. case LITERAL_int:
1744. case 44:
1745. case 45:
1746. case 46:
1747. case LITERAL_long:
1748. case LITERAL_signed:
1749. case LITERAL_unsigned:
1750. case LITERAL_float:
1751. case LITERAL_double:
1752. case LITERAL_void:
1753. case LITERAL_class:
1754. case LITERAL_struct:
1755. case LITERAL_union:
1756. case SCOPE:
1757. {
1758. {
1759. _loop119:
1760. do {
1761. switch ( LA(1)) {
1762. case LITERAL_extern:
1763. case LITERAL_auto:
1764. case LITERAL_register:
1765. case LITERAL_static:
1766. case LITERAL_mutable:
1767. {
1768. storage_class_specifier();
1769. break;
1770. }
1771. case LITERAL_const:
1772. case LITERAL_const_cast:
1773. case LITERAL_volatile:
1774. {
1775. type_qualifier();
1776. break;
1777. }
1778. case LITERAL_inline:
1779. case LITERAL__inline:
1780. case LITERAL___inline:
1781. {
1782. {
1783. switch ( LA(1)) {
1784. case LITERAL_inline:
1785. {
1786. match(LITERAL_inline);
1787. break;
1788. }
1789. case LITERAL__inline:
1790. {
1791. match(LITERAL__inline);
1792. break;
1793. }
1794. case LITERAL___inline:
1795. {
1796. match(LITERAL___inline);
1797. break;
1798. }
1799. default:
1800. {
1801. throw new NoViableAltException(LT(1), getFilename());
1802. }
1803. }
1804. }
1805. if ( inputState.guessing==0 ) {
1806. declSpecs.add("inline");
1807. }
1808. break;
1809. }
1810. case LITERAL_virtual:
1811. {
1812. match(LITERAL_virtual);
1813. if ( inputState.guessing==0 ) {
1814. declSpecs.add("virtual");
1815. }
1816. break;
1817. }
1818. case LITERAL_explicit:
1819. {
1820. match(LITERAL_explicit);
1821. if ( inputState.guessing==0 ) {
1822. declSpecs.add("explicit");
1823. }
1824. break;
1825. }
1826. case LITERAL_typedef:
1827. {
1828. match(LITERAL_typedef);
1829. if ( inputState.guessing==0 ) {
1830. td=true; declSpecs.add("typedef");
1831. }
1832. break;
1833. }
1834. case LITERAL_friend:
1835. {
1836. match(LITERAL_friend);
1837. if ( inputState.guessing==0 ) {
1838. declSpecs.add("friend");
1839. }
1840. break;
1841. }
1842. case LITERAL__stdcall:
1843. case LITERAL___stdcall:
1844. {
1845. {
1846. switch ( LA(1)) {
1847. case LITERAL__stdcall:
1848. {
1849. match(LITERAL__stdcall);
1850. break;
1851. }
1852. case LITERAL___stdcall:
1853. {
1854. match(LITERAL___stdcall);
1855. break;
1856. }
1857. default:
1858. {
1859. throw new NoViableAltException(LT(1), getFilename());
1860. }
1861. }
1862. }
1863. if ( inputState.guessing==0 ) {
1864. declSpecs.add("__stdcall");
1865. }
1866. break;
1867. }
1868. default:
1869. if ((LA(1)==LITERAL__declspec||LA(1)==LITERAL___declspec) && (LA(2)==LPAREN)) {
1870. {
1871. switch ( LA(1)) {
1872. case LITERAL__declspec:
1873. {
1874. match(LITERAL__declspec);
1875. break;
1876. }
1877. case LITERAL___declspec:
1878. {
1879. match(LITERAL___declspec);
1880. break;
1881. }
1882. default:
1883. {
1884. throw new NoViableAltException(LT(1), getFilename());
1885. }
1886. }
1887. }
1888. match(LPAREN);
1889. match(ID);
1890. match(RPAREN);
1891. }
1892. else {
1893. break _loop119;
1894. }
1895. }
1896. } while (true);
1897. }
1898. if ( inputState.guessing==0 ) {
1899. if (!declSpecs.isEmpty()) m.declarationSpecifiers(declSpecs);
1900. }
1901. type_specifier();
1902. break;
1903. }
1904. case LITERAL_typename:
1905. {
1906. match(LITERAL_typename);
1907. if ( inputState.guessing==0 ) {
1908. td=true;
1909. }
1910. direct_declarator();
1911. break;
1912. }
1913. default:
1914. {
1915. throw new NoViableAltException(LT(1), getFilename());
1916. }
1917. }
1918. }
1919. if ( inputState.guessing==0 ) {
1920. _td=td;
1921. }
1922. }
1923.
1924. public final void function_declarator() throws RecognitionException, TokenStreamException {
1925.
1926.
1927. boolean synPredMatched227 = false;
1928. if (((_tokenSet_13.member(LA(1))) && (_tokenSet_14.member(LA(2))))) {
1929. int _m227 = mark();
1930. synPredMatched227 = true;
1931. inputState.guessing++;
1932. try {
1933. {
1934. ptr_operator();
1935. }
1936. }
1937. catch (RecognitionException pe) {
1938. synPredMatched227 = false;
1939. }
1940. rewind(_m227);
1941. inputState.guessing--;
1942. }
1943. if ( synPredMatched227 ) {
1944. ptr_operator();
1945. function_declarator();
1946. }
1947. else if ((_tokenSet_15.member(LA(1))) && (_tokenSet_16.member(LA(2)))) {
1948. function_direct_declarator();
1949. }
1950. else {
1951. throw new NoViableAltException(LT(1), getFilename());
1952. }
1953.
1954. }
1955.
1956. public final void function_definition() throws RecognitionException, TokenStreamException {
1957.
1958. java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone(); auxBitSet.or(CPPvariabl...1959.
1960. {
1961. if (((_tokenSet_11.member(LA(1))) && (_tokenSet_17.member(LA(2))))&&(( !(LA(1)==SCOPE||LA(1)==ID) ...1962. declaration_specifiers();
1963. function_declarator();
1964. {
1965. if ((_tokenSet_18.member(LA(1))) && (_tokenSet_19.member(LA(2)))) {
1966. {
1967. _loop100:
1968. do {
1969. if ((_tokenSet_1.member(LA(1)))) {
1970. declaration();
1971. }
1972. else {
1973. break _loop100;
1974. }
1975.
1976. } while (true);
1977. }
1978. }
1979. else if ((LA(1)==LCURLY) && (_tokenSet_20.member(LA(2)))) {
1980. }
1981. else {
1982. throw new NoViableAltException(LT(1), getFilename());
1983. }
1984.
1985. }
1986. compound_statement();
1987. }
1988. else if ((_tokenSet_21.member(LA(1))) && (_tokenSet_22.member(LA(2)))) {
1989. function_declarator();
1990. {
1991. if ((_tokenSet_18.member(LA(1))) && (_tokenSet_19.member(LA(2)))) {
1992. {
1993. _loop103:
1994. do {
1995. if ((_tokenSet_1.member(LA(1)))) {
1996. declaration();
1997. }
1998. else {
1999. break _loop103;
2000. }
2001.
2002. } while (true);
2003. }
2004. }
2005. else if ((LA(1)==LCURLY) && (_tokenSet_20.member(LA(2)))) {
2006. }
2007. else {
2008. throw new NoViableAltException(LT(1), getFilename());
2009. }
2010.
2011. }
2012. compound_statement();
2013. }
2014. else {
2015. throw new NoViableAltException(LT(1), getFilename());
2016. }
2017.
2018. }
2019. }
2020.
2021. public final void decl_namespace() throws RecognitionException, TokenStreamException {
2022.
2023. Token ns = null;
2024. Token ns2 = null;
2025. String qid="";
2026.
2027. match(LITERAL_namespace);
2028. {
2029. if ((LA(1)==ID||LA(1)==LCURLY) && (_tokenSet_23.member(LA(2)))) {
2030. {
2031. switch ( LA(1)) {
2032. case ID:
2033. {
2034. ns = LT(1);
2035. match(ID);
2036. if ( inputState.guessing==0 ) {
2037. _td = true;declaratorID(ns.getText(),CPPvariables.QI_TYPE);
2038. }
2039. break;
2040. }
2041. case LCURLY:
2042. {
2043. break;
2044. }
2045. default:
2046. {
2047. throw new NoViableAltException(LT(1), getFilename());
2048. }
2049. }
2050. }
2051. match(LCURLY);
2052. if ( inputState.guessing==0 ) {
2053. m.enterNamespaceScope(ns.getText());
2054. }
2055. {
2056. _loop49:
2057. do {
2058. if ((_tokenSet_0.member(LA(1)))) {
2059. external_declaration();
2060. }
2061. else {
2062. break _loop49;
2063. }
2064.
2065. } while (true);
2066. }
2067. if ( inputState.guessing==0 ) {
2068. m.exitNamespaceScope();
2069. }
2070. match(RCURLY);
2071. }
2072. else if ((LA(1)==ID) && (LA(2)==ASSIGNEQUAL)) {
2073. ns2 = LT(1);
2074. match(ID);
2075. if ( inputState.guessing==0 ) {
2076. _td=true;declaratorID(ns2.getText(),CPPvariables.QI_TYPE);
2077. }
2078. match(ASSIGNEQUAL);
2079. qid=qualified_id();
2080. match(SEMICOLON);
2081. if ( inputState.guessing==0 ) {
2082. m.makeNamespaceAlias(qid, ns2.getText());
2083. }
2084. }
2085. else {
2086. throw new NoViableAltException(LT(1), getFilename());
2087. }
2088.
2089. }
2090. }
2091.
2092. public final String qualified_id() throws RecognitionException, TokenStreamException {
2093. String q="";
2094.
2095. Token id = null;
2096.
2097. String so="";
2098. String qitem="";
2099.
2100.
2101. so=scope_override();
2102. if ( inputState.guessing==0 ) {
2103. qitem=so;
2104. }
2105. {
2106. switch ( LA(1)) {
2107. case ID:
2108. {
2109. id = LT(1);
2110. match(ID);
2111. {
2112. if ((LA(1)==LESSTHAN) && (_tokenSet_24.member(LA(2)))) {
2113. match(LESSTHAN);
2114. template_argument_list();
2115. match(GREATERTHAN);
2116. }
2117. else if ((_tokenSet_25.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
2118. }
2119. else {
2120. throw new NoViableAltException(LT(1), getFilename());
2121. }
2122.
2123. }
2124. if ( inputState.guessing==0 ) {
2125.
2126. qitem=qitem+id.getText();
2127.
2128. }
2129. break;
2130. }
2131. case OPERATOR:
2132. {
2133. match(OPERATOR);
2134. optor();
2135. if ( inputState.guessing==0 ) {
2136. qitem=qitem+"operator"+"NYI";
2137. }
2138. break;
2139. }
2140. case LITERAL_this:
2141. {
2142. match(LITERAL_this);
2143. break;
2144. }
2145. case LITERAL_true:
2146. case LITERAL_false:
2147. {
2148. {
2149. switch ( LA(1)) {
2150. case LITERAL_true:
2151. {
2152. match(LITERAL_true);
2153. break;
2154. }
2155. case LITERAL_false:
2156. {
2157. match(LITERAL_false);
2158. break;
2159. }
2160. default:
2161. {
2162. throw new NoViableAltException(LT(1), getFilename());
2163. }
2164. }
2165. }
2166. break;
2167. }
2168. default:
2169. {
2170. throw new NoViableAltException(LT(1), getFilename());
2171. }
2172. }
2173. }
2174. if ( inputState.guessing==0 ) {
2175. q = qitem;
2176. }
2177. return q;
2178. }
2179.
2180. public final void member_declaration() throws RecognitionException, TokenStreamException {
2181.
2182. String q="";
2183.
2184. if ( inputState.guessing==0 ) {
2185. m.beginMemberDeclaration();
2186. }
2187. {
2188. switch ( LA(1)) {
2189. case LITERAL_public:
2190. case LITERAL_protected:
2191. case LITERAL_private:
2192. {
2193. access_specifier();
2194. match(COLON);
2195. break;
2196. }
2197. case SEMICOLON:
2198. {
2199. match(SEMICOLON);
2200. break;
2201. }
2202. default:
2203. boolean synPredMatched54 = false;
2204. if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
2205. int _m54 = mark();
2206. synPredMatched54 = true;
2207. inputState.guessing++;
2208. try {
2209. {
2210. {
2211. switch ( LA(1)) {
2212. case LITERAL_typedef:
2213. {
2214. match(LITERAL_typedef);
2215. break;
2216. }
2217. case LITERAL_class:
2218. case LITERAL_struct:
2219. case LITERAL_union:
2220. {
2221. break;
2222. }
2223. default:
2224. {
2225. throw new NoViableAltException(LT(1), getFilename());
2226. }
2227. }
2228. }
2229. class_head();
2230. }
2231. }
2232. catch (RecognitionException pe) {
2233. synPredMatched54 = false;
2234. }
2235. rewind(_m54);
2236. inputState.guessing--;
2237. }
2238. if ( synPredMatched54 ) {
2239. declaration();
2240. }
2241. else {
2242. boolean synPredMatched57 = false;
2243. if (((LA(1)==LITERAL_enum) && (LA(2)==ID||LA(2)==LCURLY))) {
2244. int _m57 = mark();
2245. synPredMatched57 = true;
2246. inputState.guessing++;
2247. try {
2248. {
2249. match(LITERAL_enum);
2250. {
2251. switch ( LA(1)) {
2252. case ID:
2253. {
2254. match(ID);
2255. break;
2256. }
2257. case LCURLY:
2258. {
2259. break;
2260. }
2261. default:
2262. {
2263. throw new NoViableAltException(LT(1), getFilename());
2264. }
2265. }
2266. }
2267. match(LCURLY);
2268. }
2269. }
2270. catch (RecognitionException pe) {
2271. synPredMatched57 = false;
2272. }
2273. rewind(_m57);
2274. inputState.guessing--;
2275. }
2276. if ( synPredMatched57 ) {
2277. enum_specifier();
2278. {
2279. switch ( LA(1)) {
2280. case ID:
2281. case COLON:
2282. case LITERAL__stdcall:
2283. case LITERAL___stdcall:
2284. case LPAREN:
2285. case OPERATOR:
2286. case LITERAL_this:
2287. case LITERAL_true:
2288. case LITERAL_false:
2289. case STAR:
2290. case AMPERSAND:
2291. case TILDE:
2292. case SCOPE:
2293. case LITERAL__cdecl:
2294. case LITERAL___cdecl:
2295. case LITERAL__near:
2296. case LITERAL___near:
2297. case LITERAL__far:
2298. case LITERAL___far:
2299. case LITERAL___interrupt:
2300. case LITERAL_pascal:
2301. case LITERAL__pascal:
2302. case LITERAL___pascal:
2303. {
2304. member_declarator_list();
2305. break;
2306. }
2307. case SEMICOLON:
2308. {
2309. break;
2310. }
2311. default:
2312. {
2313. throw new NoViableAltException(LT(1), getFilename());
2314. }
2315. }
2316. }
2317. match(SEMICOLON);
2318. }
2319. else {
2320. boolean synPredMatched60 = false;
2321. if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
2322. int _m60 = mark();
2323. synPredMatched60 = true;
2324. inputState.guessing++;
2325. try {
2326. {
2327. template_head();
2328. class_head();
2329. }
2330. }
2331. catch (RecognitionException pe) {
2332. synPredMatched60 = false;
2333. }
2334. rewind(_m60);
2335. inputState.guessing--;
2336. }
2337. if ( synPredMatched60 ) {
2338. template_head();
2339. declaration();
2340. }
2341. else {
2342. boolean synPredMatched62 = false;
2343. if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
2344. int _m62 = mark();
2345. synPredMatched62 = true;
2346. inputState.guessing++;
2347. try {
2348. {
2349. ctor_decl_spec();
2350. if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
2351. throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
2352. ctor_declarator();
2353. match(SEMICOLON);
2354. }
2355. }
2356. catch (RecognitionException pe) {
2357. synPredMatched62 = false;
2358. }
2359. rewind(_m62);
2360. inputState.guessing--;
2361. }
2362. if ( synPredMatched62 ) {
2363. ctor_decl_spec();
2364. ctor_declarator();
2365. match(SEMICOLON);
2366. }
2367. else {
2368. boolean synPredMatched65 = false;
2369. if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
2370. int _m65 = mark();
2371. synPredMatched65 = true;
2372. inputState.guessing++;
2373. try {
2374. {
2375. ctor_decl_spec();
2376. if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
2377. throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
2378. ctor_declarator();
2379. {
2380. switch ( LA(1)) {
2381. case COLON:
2382. {
2383. match(COLON);
2384. break;
2385. }
2386. case LCURLY:
2387. {
2388. match(LCURLY);
2389. break;
2390. }
2391. default:
2392. {
2393. throw new NoViableAltException(LT(1), getFilename());
2394. }
2395. }
2396. }
2397. }
2398. }
2399. catch (RecognitionException pe) {
2400. synPredMatched65 = false;
2401. }
2402. rewind(_m65);
2403. inputState.guessing--;
2404. }
2405. if ( synPredMatched65 ) {
2406. ctor_definition();
2407. }
2408. else {
2409. boolean synPredMatched67 = false;
2410. if (((_tokenSet_27.member(LA(1))) && (_tokenSet_4.member(LA(2))))) {
2411. int _m67 = mark();
2412. synPredMatched67 = true;
2413. inputState.guessing++;
2414. try {
2415. {
2416. dtor_head();
2417. match(SEMICOLON);
2418. }
2419. }
2420. catch (RecognitionException pe) {
2421. synPredMatched67 = false;
2422. }
2423. rewind(_m67);
2424. inputState.guessing--;
2425. }
2426. if ( synPredMatched67 ) {
2427. dtor_head();
2428. match(SEMICOLON);
2429. }
2430. else {
2431. boolean synPredMatched69 = false;
2432. if (((_tokenSet_27.member(LA(1))) && (_tokenSet_4.member(LA(2))))) {
2433. int _m69 = mark();
2434. synPredMatched69 = true;
2435. inputState.guessing++;
2436. try {
2437. {
2438. dtor_head();
2439. match(LCURLY);
2440. }
2441. }
2442. catch (RecognitionException pe) {
2443. synPredMatched69 = false;
2444. }
2445. rewind(_m69);
2446. inputState.guessing--;
2447. }
2448. if ( synPredMatched69 ) {
2449. dtor_head();
2450. dtor_body();
2451. }
2452. else {
2453. boolean synPredMatched71 = false;
2454. if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
2455. int _m71 = mark();
2456. synPredMatched71 = true;
2457. inputState.guessing++;
2458. try {
2459. {
2460. declaration_specifiers();
2461. function_declarator();
2462. match(SEMICOLON);
2463. }
2464. }
2465. catch (RecognitionException pe) {
2466. synPredMatched71 = false;
2467. }
2468. rewind(_m71);
2469. inputState.guessing--;
2470. }
2471. if ( synPredMatched71 ) {
2472. if ( inputState.guessing==0 ) {
2473. m.beginFunctionDeclaration();
2474. }
2475. declaration();
2476. if ( inputState.guessing==0 ) {
2477. m.endFunctionDeclaration();
2478. }
2479. }
2480. else {
2481. boolean synPredMatched73 = false;
2482. if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
2483. int _m73 = mark();
2484. synPredMatched73 = true;
2485. inputState.guessing++;
2486. try {
2487. {
2488. declaration_specifiers();
2489. function_declarator();
2490. match(LCURLY);
2491. }
2492. }
2493. catch (RecognitionException pe) {
2494. synPredMatched73 = false;
2495. }
2496. rewind(_m73);
2497. inputState.guessing--;
2498. }
2499. if ( synPredMatched73 ) {
2500. if ( inputState.guessing==0 ) {
2501. m.beginFunctionDefinition();
2502. }
2503. function_definition();
2504. if ( inputState.guessing==0 ) {
2505. m.endFunctionDefinition();
2506. }
2507. }
2508. else {
2509. boolean synPredMatched76 = false;
2510. if (((LA(1)==LITERAL_inline||LA(1)==OPERATOR) && (_tokenSet_28.member(LA(2))))) {
2511. int _m76 = mark();
2512. synPredMatched76 = true;
2513. inputState.guessing++;
2514. try {
2515. {
2516. {
2517. switch ( LA(1)) {
2518. case LITERAL_inline:
2519. {
2520. match(LITERAL_inline);
2521. break;
2522. }
2523. case OPERATOR:
2524. {
2525. break;
2526. }
2527. default:
2528. {
2529. throw new NoViableAltException(LT(1), getFilename());
2530. }
2531. }
2532. }
2533. conversion_function_decl_or_def();
2534. }
2535. }
2536. catch (RecognitionException pe) {
2537. synPredMatched76 = false;
2538. }
2539. rewind(_m76);
2540. inputState.guessing--;
2541. }
2542. if ( synPredMatched76 ) {
2543. {
2544. switch ( LA(1)) {
2545. case LITERAL_inline:
2546. {
2547. match(LITERAL_inline);
2548. break;
2549. }
2550. case OPERATOR:
2551. {
2552. break;
2553. }
2554. default:
2555. {
2556. throw new NoViableAltException(LT(1), getFilename());
2557. }
2558. }
2559. }
2560. conversion_function_decl_or_def();
2561. }
2562. else {
2563. boolean synPredMatched79 = false;
2564. if (((_tokenSet_29.member(LA(1))) && (_tokenSet_30.member(LA(2))))) {
2565. int _m79 = mark();
2566. synPredMatched79 = true;
2567. inputState.guessing++;
2568. try {
2569. {
2570. qualified_id();
2571. match(SEMICOLON);
2572. }
2573. }
2574. catch (RecognitionException pe) {
2575. synPredMatched79 = false;
2576. }
2577. rewind(_m79);
2578. inputState.guessing--;
2579. }
2580. if ( synPredMatched79 ) {
2581. q=qualified_id();
2582. match(SEMICOLON);
2583. }
2584. else {
2585. boolean synPredMatched81 = false;
2586. if (((_tokenSet_11.member(LA(1))) && (_tokenSet_31.member(LA(2))))) {
2587. int _m81 = mark();
2588. synPredMatched81 = true;
2589. inputState.guessing++;
2590. try {
2591. {
2592. declaration_specifiers();
2593. }
2594. }
2595. catch (RecognitionException pe) {
2596. synPredMatched81 = false;
2597. }
2598. rewind(_m81);
2599. inputState.guessing--;
2600. }
2601. if ( synPredMatched81 ) {
2602. declaration_specifiers();
2603. {
2604. switch ( LA(1)) {
2605. case ID:
2606. case COLON:
2607. case LITERAL__stdcall:
2608. case LITERAL___stdcall:
2609. case LPAREN:
2610. case OPERATOR:
2611. case LITERAL_this:
2612. case LITERAL_true:
2613. case LITERAL_false:
2614. case STAR:
2615. case AMPERSAND:
2616. case TILDE:
2617. case SCOPE:
2618. case LITERAL__cdecl:
2619. case LITERAL___cdecl:
2620. case LITERAL__near:
2621. case LITERAL___near:
2622. case LITERAL__far:
2623. case LITERAL___far:
2624. case LITERAL___interrupt:
2625. case LITERAL_pascal:
2626. case LITERAL__pascal:
2627. case LITERAL___pascal:
2628. {
2629. member_declarator_list();
2630. break;
2631. }
2632. case SEMICOLON:
2633. {
2634. break;
2635. }
2636. default:
2637. {
2638. throw new NoViableAltException(LT(1), getFilename());
2639. }
2640. }
2641. }
2642. match(SEMICOLON);
2643. }
2644. else {
2645. boolean synPredMatched84 = false;
2646. if (((_tokenSet_21.member(LA(1))) && (_tokenSet_22.member(LA(2))))) {
2647. int _m84 = mark();
2648. synPredMatched84 = true;
2649. inputState.guessing++;
2650. try {
2651. {
2652. function_declarator();
2653. match(SEMICOLON);
2654. }
2655. }
2656. catch (RecognitionException pe) {
2657. synPredMatched84 = false;
2658. }
2659. rewind(_m84);
2660. inputState.guessing--;
2661. }
2662. if ( synPredMatched84 ) {
2663. function_declarator();
2664. match(SEMICOLON);
2665. }
2666. else if ((_tokenSet_21.member(LA(1))) && (_tokenSet_22.member(LA(2)))) {
2667. function_declarator();
2668. compound_statement();
2669. }
2670. else {
2671. boolean synPredMatched87 = false;
2672. if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
2673. int _m87 = mark();
2674. synPredMatched87 = true;
2675. inputState.guessing++;
2676. try {
2677. {
2678. template_head();
2679. declaration_specifiers();
2680. {
2681. switch ( LA(1)) {
2682. case ID:
2683. case LITERAL__stdcall:
2684. case LITERAL___stdcall:
2685. case LPAREN:
2686. case OPERATOR:
2687. case LITERAL_this:
2688. case LITERAL_true:
2689. case LITERAL_false:
2690. case STAR:
2691. case AMPERSAND:
2692. case TILDE:
2693. case SCOPE:
2694. case LITERAL__cdecl:
2695. case LITERAL___cdecl:
2696. case LITERAL__near:
2697. case LITERAL___near:
2698. case LITERAL__far:
2699. case LITERAL___far:
2700. case LITERAL___interrupt:
2701. case LITERAL_pascal:
2702. case LITERAL__pascal:
2703. case LITERAL___pascal:
2704. {
2705. init_declarator_list();
2706. break;
2707. }
2708. case SEMICOLON:
2709. {
2710. break;
2711. }
2712. default:
2713. {
2714. throw new NoViableAltException(LT(1), getFilename());
2715. }
2716. }
2717. }
2718. match(SEMICOLON);
2719. }
2720. }
2721. catch (RecognitionException pe) {
2722. synPredMatched87 = false;
2723. }
2724. rewind(_m87);
2725. inputState.guessing--;
2726. }
2727. if ( synPredMatched87 ) {
2728. template_head();
2729. declaration_specifiers();
2730. {
2731. switch ( LA(1)) {
2732. case ID:
2733. case LITERAL__stdcall:
2734. case LITERAL___stdcall:
2735. case LPAREN:
2736. case OPERATOR:
2737. case LITERAL_this:
2738. case LITERAL_true:
2739. case LITERAL_false:
2740. case STAR:
2741. case AMPERSAND:
2742. case TILDE:
2743. case SCOPE:
2744. case LITERAL__cdecl:
2745. case LITERAL___cdecl:
2746. case LITERAL__near:
2747. case LITERAL___near:
2748. case LITERAL__far:
2749. case LITERAL___far:
2750. case LITERAL___interrupt:
2751. case LITERAL_pascal:
2752. case LITERAL__pascal:
2753. case LITERAL___pascal:
2754. {
2755. init_declarator_list();
2756. break;
2757. }
2758. case SEMICOLON:
2759. {
2760. break;
2761. }
2762. default:
2763. {
2764. throw new NoViableAltException(LT(1), getFilename());
2765. }
2766. }
2767. }
2768. match(SEMICOLON);
2769. }
2770. else if ((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN)) {
2771. template_head();
2772. {
2773. boolean synPredMatched91 = false;
2774. if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
2775. int _m91 = mark();
2776. synPredMatched91 = true;
2777. inputState.guessing++;
2778. try {
2779. {
2780. ctor_decl_spec();
2781. if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
2782. throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
2783. }
2784. }
2785. catch (RecognitionException pe) {
2786. synPredMatched91 = false;
2787. }
2788. rewind(_m91);
2789. inputState.guessing--;
2790. }
2791. if ( synPredMatched91 ) {
2792. ctor_definition();
2793. }
2794. else {
2795. boolean synPredMatched93 = false;
2796. if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
2797. int _m93 = mark();
2798. synPredMatched93 = true;
2799. inputState.guessing++;
2800. try {
2801. {
2802. declaration_specifiers();
2803. function_declarator();
2804. match(SEMICOLON);
2805. }
2806. }
2807. catch (RecognitionException pe) {
2808. synPredMatched93 = false;
2809. }
2810. rewind(_m93);
2811. inputState.guessing--;
2812. }
2813. if ( synPredMatched93 ) {
2814. declaration();
2815. }
2816. else {
2817. boolean synPredMatched95 = false;
2818. if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
2819. int _m95 = mark();
2820. synPredMatched95 = true;
2821. inputState.guessing++;
2822. try {
2823. {
2824. declaration_specifiers();
2825. function_declarator();
2826. match(LCURLY);
2827. }
2828. }
2829. catch (RecognitionException pe) {
2830. synPredMatched95 = false;
2831. }
2832. rewind(_m95);
2833. inputState.guessing--;
2834. }
2835. if ( synPredMatched95 ) {
2836. function_definition();
2837. }
2838. else if ((LA(1)==OPERATOR) && (_tokenSet_11.member(LA(2)))) {
2839. conversion_function_decl_or_def();
2840. }
2841. else {
2842. throw new NoViableAltException(LT(1), getFilename());
2843. }
2844. }}
2845. }
2846. }
2847. else {
2848. throw new NoViableAltException(LT(1), getFilename());
2849. }
2850. }}}}}}}}}}}}}}
2851. }
2852. if ( inputState.guessing==0 ) {
2853. m.endMemberDeclaration();
2854. }
2855. }
2856.
2857. public final void member_declarator_list() throws RecognitionException, TokenStreamException {
2858.
2859. m.beginMemberDeclaratorList();
2860.
2861. {
2862. member_declarator();
2863. {
2864. switch ( LA(1)) {
2865. case ASSIGNEQUAL:
2866. {
2867. match(ASSIGNEQUAL);
2868. match(OCTALINT);
2869. break;
2870. }
2871. case SEMICOLON:
2872. case COMMA:
2873. {
2874. break;
2875. }
2876. default:
2877. {
2878. throw new NoViableAltException(LT(1), getFilename());
2879. }
2880. }
2881. }
2882. {
2883. _loop180:
2884. do {
2885. if ((LA(1)==COMMA)) {
2886. match(COMMA);
2887. member_declarator();
2888. {
2889. switch ( LA(1)) {
2890. case ASSIGNEQUAL:
2891. {
2892. match(ASSIGNEQUAL);
2893. match(OCTALINT);
2894. break;
2895. }
2896. case SEMICOLON:
2897. case COMMA:
2898. {
2899. break;
2900. }
2901. default:
2902. {
2903. throw new NoViableAltException(LT(1), getFilename());
2904. }
2905. }
2906. }
2907. }
2908. else {
2909. break _loop180;
2910. }
2911.
2912. } while (true);
2913. }
2914. }
2915. if ( inputState.guessing==0 ) {
2916. m.endMemberDeclaratorList();
2917. }
2918. }
2919.
2920. public final void ctor_declarator() throws RecognitionException, TokenStreamException {
2921.
2922. String q="";
2923.
2924. q=qualified_ctor_id();
2925. if ( inputState.guessing==0 ) {
2926. m.qualifiedCtorId(q);
2927. }
2928. match(LPAREN);
2929. {
2930. switch ( LA(1)) {
2931. case LITERAL_typedef:
2932. case LITERAL_enum:
2933. case ID:
2934. case LITERAL_inline:
2935. case LITERAL_extern:
2936. case LITERAL__inline:
2937. case LITERAL___inline:
2938. case LITERAL_virtual:
2939. case LITERAL_explicit:
2940. case LITERAL_friend:
2941. case LITERAL__stdcall:
2942. case LITERAL___stdcall:
2943. case LITERAL__declspec:
2944. case LITERAL___declspec:
2945. case LPAREN:
2946. case LITERAL_typename:
2947. case LITERAL_auto:
2948. case LITERAL_register:
2949. case LITERAL_static:
2950. case LITERAL_mutable:
2951. case LITERAL_const:
2952. case LITERAL_const_cast:
2953. case LITERAL_volatile:
2954. case LITERAL_char:
2955. case LITERAL_wchar_t:
2956. case LITERAL_bool:
2957. case LITERAL_short:
2958. case LITERAL_int:
2959. case 44:
2960. case 45:
2961. case 46:
2962. case LITERAL_long:
2963. case LITERAL_signed:
2964. case LITERAL_unsigned:
2965. case LITERAL_float:
2966. case LITERAL_double:
2967. case LITERAL_void:
2968. case LITERAL_class:
2969. case LITERAL_struct:
2970. case LITERAL_union:
2971. case OPERATOR:
2972. case LITERAL_this:
2973. case LITERAL_true:
2974. case LITERAL_false:
2975. case STAR:
2976. case AMPERSAND:
2977. case TILDE:
2978. case ELLIPSIS:
2979. case SCOPE:
2980. case LITERAL__cdecl:
2981. case LITERAL___cdecl:
2982. case LITERAL__near:
2983. case LITERAL___near:
2984. case LITERAL__far:
2985. case LITERAL___far:
2986. case LITERAL___interrupt:
2987. case LITERAL_pascal:
2988. case LITERAL__pascal:
2989. case LITERAL___pascal:
2990. {
2991. parameter_list();
2992. break;
2993. }
2994. case RPAREN:
2995. {
2996. break;
2997. }
2998. default:
2999. {
3000. throw new NoViableAltException(LT(1), getFilename());
3001. }
3002. }
3003. }
3004. match(RPAREN);
3005. {
3006. switch ( LA(1)) {
3007. case LITERAL_throw:
3008. {
3009. exception_specification();
3010. break;
3011. }
3012. case LCURLY:
3013. case SEMICOLON:
3014. case COLON:
3015. {
3016. break;
3017. }
3018. default:
3019. {
3020. throw new NoViableAltException(LT(1), getFilename());
3021. }
3022. }
3023. }
3024. }
3025.
3026. public final void compound_statement() throws RecognitionException, TokenStreamException {
3027.
3028.
3029. if ( inputState.guessing==0 ) {
3030. m.beginCompoundStatement();
3031. }
3032. match(LCURLY);
3033. {
3034. switch ( LA(1)) {
3035. case LITERAL_typedef:
3036. case LITERAL_enum:
3037. case ID:
3038. case LCURLY:
3039. case SEMICOLON:
3040. case LITERAL_inline:
3041. case LITERAL_extern:
3042. case StringLiteral:
3043. case LITERAL__inline:
3044. case LITERAL___inline:
3045. case LITERAL_virtual:
3046. case LITERAL_explicit:
3047. case LITERAL_friend:
3048. case LITERAL__stdcall:
3049. case LITERAL___stdcall:
3050. case LITERAL__declspec:
3051. case LITERAL___declspec:
3052. case LPAREN:
3053. case LITERAL_typename:
3054. case LITERAL_auto:
3055. case LITERAL_register:
3056. case LITERAL_static:
3057. case LITERAL_mutable:
3058. case LITERAL_const:
3059. case LITERAL_const_cast:
3060. case LITERAL_volatile:
3061. case LITERAL_char:
3062. case LITERAL_wchar_t:
3063. case LITERAL_bool:
3064. case LITERAL_short:
3065. case LITERAL_int:
3066. case 44:
3067. case 45:
3068. case 46:
3069. case LITERAL_long:
3070. case LITERAL_signed:
3071. case LITERAL_unsigned:
3072. case LITERAL_float:
3073. case LITERAL_double:
3074. case LITERAL_void:
3075. case LITERAL_class:
3076. case LITERAL_struct:
3077. case LITERAL_union:
3078. case OPERATOR:
3079. case LITERAL_this:
3080. case LITERAL_true:
3081. case LITERAL_false:
3082. case OCTALINT:
3083. case STAR:
3084. case AMPERSAND:
3085. case TILDE:
3086. case LITERAL_throw:
3087. case LITERAL_case:
3088. case LITERAL_default:
3089. case LITERAL_if:
3090. case LITERAL_switch:
3091. case LITERAL_while:
3092. case LITERAL_do:
3093. case LITERAL_for:
3094. case LITERAL_goto:
3095. case LITERAL_continue:
3096. case LITERAL_break:
3097. case LITERAL_return:
3098. case LITERAL_try:
3099. case LITERAL_using:
3100. case LITERAL__asm:
3101. case LITERAL___asm:
3102. case PLUS:
3103. case MINUS:
3104. case PLUSPLUS:
3105. case MINUSMINUS:
3106. case LITERAL_sizeof:
3107. case SCOPE:
3108. case LITERAL_dynamic_cast:
3109. case LITERAL_static_cast:
3110. case LITERAL_reinterpret_cast:
3111. case NOT:
3112. case LITERAL_new:
3113. case LITERAL_delete:
3114. case DECIMALINT:
3115. case HEXADECIMALINT:
3116. case CharLiteral:
3117. case FLOATONE:
3118. case FLOATTWO:
3119. {
3120. statement_list();
3121. break;
3122. }
3123. case RCURLY:
3124. {
3125. break;
3126. }
3127. default:
3128. {
3129. throw new NoViableAltException(LT(1), getFilename());
3130. }
3131. }
3132. }
3133. match(RCURLY);
3134. if ( inputState.guessing==0 ) {
3135. m.endCompoundStatement();
3136. }
3137. }
3138.
3139. public final void access_specifier() throws RecognitionException, TokenStreamException {
3140.
3141.
3142. switch ( LA(1)) {
3143. case LITERAL_public:
3144. {
3145. match(LITERAL_public);
3146. if ( inputState.guessing==0 ) {
3147. m.accessSpecifier("public");
3148. }
3149. break;
3150. }
3151. case LITERAL_protected:
3152. {
3153. match(LITERAL_protected);
3154. if ( inputState.guessing==0 ) {
3155. m.accessSpecifier("protected");
3156. }
3157. break;
3158. }
3159. case LITERAL_private:
3160. {
3161. match(LITERAL_private);
3162. if ( inputState.guessing==0 ) {
3163. m.accessSpecifier("private");
3164. }
3165. break;
3166. }
3167. default:
3168. {
3169. throw new NoViableAltException(LT(1), getFilename());
3170. }
3171. }
3172. }
3173.
3174. public final void linkage_specification() throws RecognitionException, TokenStreamException {
3175.
3176.
3177. match(LITERAL_extern);
3178. match(StringLiteral);
3179. {
3180. switch ( LA(1)) {
3181. case LCURLY:
3182. {
3183. match(LCURLY);
3184. {
3185. _loop112:
3186. do {
3187. if ((_tokenSet_0.member(LA(1)))) {
3188. external_declaration();
3189. }
3190. else {
3191. break _loop112;
3192. }
3193.
3194. } while (true);
3195. }
3196. match(RCURLY);
3197. break;
3198. }
3199. case LITERAL_typedef:
3200. case LITERAL_enum:
3201. case ID:
3202. case LITERAL_inline:
3203. case LITERAL_extern:
3204. case LITERAL__inline:
3205. case LITERAL___inline:
3206. case LITERAL_virtual:
3207. case LITERAL_explicit:
3208. case LITERAL_friend:
3209. case LITERAL__stdcall:
3210. case LITERAL___stdcall:
3211. case LITERAL__declspec:
3212. case LITERAL___declspec:
3213. case LITERAL_typename:
3214. case LITERAL_auto:
3215. case LITERAL_register:
3216. case LITERAL_static:
3217. case LITERAL_mutable:
3218. case LITERAL_const:
3219. case LITERAL_const_cast:
3220. case LITERAL_volatile:
3221. case LITERAL_char:
3222. case LITERAL_wchar_t:
3223. case LITERAL_bool:
3224. case LITERAL_short:
3225. case LITERAL_int:
3226. case 44:
3227. case 45:
3228. case 46:
3229. case LITERAL_long:
3230. case LITERAL_signed:
3231. case LITERAL_unsigned:
3232. case LITERAL_float:
3233. case LITERAL_double:
3234. case LITERAL_void:
3235. case LITERAL_class:
3236. case LITERAL_struct:
3237. case LITERAL_union:
3238. case LITERAL_using:
3239. case SCOPE:
3240. {
3241. declaration();
3242. break;
3243. }
3244. default:
3245. {
3246. throw new NoViableAltException(LT(1), getFilename());
3247. }
3248. }
3249. }
3250. }
3251.
3252. public final void using_declaration() throws RecognitionException, TokenStreamException {
3253.
3254. String qid="";
3255.
3256. match(LITERAL_using);
3257. {
3258. switch ( LA(1)) {
3259. case LITERAL_namespace:
3260. {
3261. match(LITERAL_namespace);
3262. qid=qualified_id();
3263. break;
3264. }
3265. case ID:
3266. case OPERATOR:
3267. case LITERAL_this:
3268. case LITERAL_true:
3269. case LITERAL_false:
3270. case SCOPE:
3271. {
3272. qid=qualified_id();
3273. break;
3274. }
3275. default:
3276. {
3277. throw new NoViableAltException(LT(1), getFilename());
3278. }
3279. }
3280. }
3281. match(SEMICOLON);
3282. }
3283.
3284. public final void storage_class_specifier() throws RecognitionException, TokenStreamException {
3285.
3286.
3287. switch ( LA(1)) {
3288. case LITERAL_auto:
3289. {
3290. match(LITERAL_auto);
3291. if ( inputState.guessing==0 ) {
3292. m.storageClassSpecifier("auto");
3293. }
3294. break;
3295. }
3296. case LITERAL_register:
3297. {
3298. match(LITERAL_register);
3299. if ( inputState.guessing==0 ) {
3300. m.storageClassSpecifier("register");
3301. }
3302. break;
3303. }
3304. case LITERAL_static:
3305. {
3306. match(LITERAL_static);
3307. if ( inputState.guessing==0 ) {
3308. m.storageClassSpecifier("static");
3309. }
3310. break;
3311. }
3312. case LITERAL_extern:
3313. {
3314. match(LITERAL_extern);
3315. if ( inputState.guessing==0 ) {
3316. m.storageClassSpecifier("extern");
3317. }
3318. break;
3319. }
3320. case LITERAL_mutable:
3321. {
3322. match(LITERAL_mutable);
3323. if ( inputState.guessing==0 ) {
3324. m.storageClassSpecifier("mutable");
3325. }
3326. break;
3327. }
3328. default:
3329. {
3330. throw new NoViableAltException(LT(1), getFilename());
3331. }
3332. }
3333. }
3334.
3335. public final void type_qualifier() throws RecognitionException, TokenStreamException {
3336.
3337.
3338. switch ( LA(1)) {
3339. case LITERAL_const:
3340. case LITERAL_const_cast:
3341. {
3342. {
3343. switch ( LA(1)) {
3344. case LITERAL_const:
3345. {
3346. match(LITERAL_const);
3347. break;
3348. }
3349. case LITERAL_const_cast:
3350. {
3351. match(LITERAL_const_cast);
3352. break;
3353. }
3354. default:
3355. {
3356. throw new NoViableAltException(LT(1), getFilename());
3357. }
3358. }
3359. }
3360. if ( inputState.guessing==0 ) {
3361. m.typeQualifier("const");
3362. }
3363. break;
3364. }
3365. case LITERAL_volatile:
3366. {
3367. match(LITERAL_volatile);
3368. if ( inputState.guessing==0 ) {
3369. m.typeQualifier("volatile");
3370. }
3371. break;
3372. }
3373. default:
3374. {
3375. throw new NoViableAltException(LT(1), getFilename());
3376. }
3377. }
3378. }
3379.
3380. public final void type_specifier() throws RecognitionException, TokenStreamException {
3381.
3382.
3383. switch ( LA(1)) {
3384. case ID:
3385. case LITERAL__declspec:
3386. case LITERAL___declspec:
3387. case LITERAL_char:
3388. case LITERAL_wchar_t:
3389. case LITERAL_bool:
3390. case LITERAL_short:
3391. case LITERAL_int:
3392. case 44:
3393. case 45:
3394. case 46:
3395. case LITERAL_long:
3396. case LITERAL_signed:
3397. case LITERAL_unsigned:
3398. case LITERAL_float:
3399. case LITERAL_double:
3400. case LITERAL_void:
3401. case SCOPE:
3402. {
3403. simple_type_specifier();
3404. break;
3405. }
3406. case LITERAL_class:
3407. case LITERAL_struct:
3408. case LITERAL_union:
3409. {
3410. class_specifier();
3411. break;
3412. }
3413. case LITERAL_enum:
3414. {
3415. enum_specifier();
3416. break;
3417. }
3418. default:
3419. {
3420. throw new NoViableAltException(LT(1), getFilename());
3421. }
3422. }
3423. }
3424.
3425. public final void direct_declarator() throws RecognitionException, TokenStreamException {
3426.
3427. Token dtor = null;
3428. String id="";
3429.
3430. switch ( LA(1)) {
3431. case TILDE:
3432. {
3433. match(TILDE);
3434. dtor = LT(1);
3435. match(ID);
3436. if ( inputState.guessing==0 ) {
3437. declaratorID(dtor.getText(),CPPvariables.QI_DTOR);
3438. }
3439. match(LPAREN);
3440. {
3441. switch ( LA(1)) {
3442. case LITERAL_typedef:
3443. case LITERAL_enum:
3444. case ID:
3445. case LITERAL_inline:
3446. case LITERAL_extern:
3447. case LITERAL__inline:
3448. case LITERAL___inline:
3449. case LITERAL_virtual:
3450. case LITERAL_explicit:
3451. case LITERAL_friend:
3452. case LITERAL__stdcall:
3453. case LITERAL___stdcall:
3454. case LITERAL__declspec:
3455. case LITERAL___declspec:
3456. case LPAREN:
3457. case LITERAL_typename:
3458. case LITERAL_auto:
3459. case LITERAL_register:
3460. case LITERAL_static:
3461. case LITERAL_mutable:
3462. case LITERAL_const:
3463. case LITERAL_const_cast:
3464. case LITERAL_volatile:
3465. case LITERAL_char:
3466. case LITERAL_wchar_t:
3467. case LITERAL_bool:
3468. case LITERAL_short:
3469. case LITERAL_int:
3470. case 44:
3471. case 45:
3472. case 46:
3473. case LITERAL_long:
3474. case LITERAL_signed:
3475. case LITERAL_unsigned:
3476. case LITERAL_float:
3477. case LITERAL_double:
3478. case LITERAL_void:
3479. case LITERAL_class:
3480. case LITERAL_struct:
3481. case LITERAL_union:
3482. case OPERATOR:
3483. case LITERAL_this:
3484. case LITERAL_true:
3485. case LITERAL_false:
3486. case STAR:
3487. case AMPERSAND:
3488. case TILDE:
3489. case ELLIPSIS:
3490. case SCOPE:
3491. case LITERAL__cdecl:
3492. case LITERAL___cdecl:
3493. case LITERAL__near:
3494. case LITERAL___near:
3495. case LITERAL__far:
3496. case LITERAL___far:
3497. case LITERAL___interrupt:
3498. case LITERAL_pascal:
3499. case LITERAL__pascal:
3500. case LITERAL___pascal:
3501. {
3502. parameter_list();
3503. break;
3504. }
3505. case RPAREN:
3506. {
3507. break;
3508. }
3509. default:
3510. {
3511. throw new NoViableAltException(LT(1), getFilename());
3512. }
3513. }
3514. }
3515. match(RPAREN);
3516. break;
3517. }
3518. case LPAREN:
3519. {
3520. match(LPAREN);
3521. declarator();
3522. match(RPAREN);
3523. declarator_suffixes();
3524. break;
3525. }
3526. default:
3527. boolean synPredMatched203 = false;
3528. if (((_tokenSet_29.member(LA(1))) && (_tokenSet_16.member(LA(2))))) {
3529. int _m203 = mark();
3530. synPredMatched203 = true;
3531. inputState.guessing++;
3532. try {
3533. {
3534. qualified_id();
3535. match(LPAREN);
3536. {
3537. switch ( LA(1)) {
3538. case RPAREN:
3539. {
3540. match(RPAREN);
3541. break;
3542. }
3543. case LITERAL_typedef:
3544. case LITERAL_enum:
3545. case ID:
3546. case LITERAL_inline:
3547. case LITERAL_extern:
3548. case LITERAL__inline:
3549. case LITERAL___inline:
3550. case LITERAL_virtual:
3551. case LITERAL_explicit:
3552. case LITERAL_friend:
3553. case LITERAL__stdcall:
3554. case LITERAL___stdcall:
3555. case LITERAL__declspec:
3556. case LITERAL___declspec:
3557. case LITERAL_typename:
3558. case LITERAL_auto:
3559. case LITERAL_register:
3560. case LITERAL_static:
3561. case LITERAL_mutable:
3562. case LITERAL_const:
3563. case LITERAL_const_cast:
3564. case LITERAL_volatile:
3565. case LITERAL_char:
3566. case LITERAL_wchar_t:
3567. case LITERAL_bool:
3568. case LITERAL_short:
3569. case LITERAL_int:
3570. case 44:
3571. case 45:
3572. case 46:
3573. case LITERAL_long:
3574. case LITERAL_signed:
3575. case LITERAL_unsigned:
3576. case LITERAL_float:
3577. case LITERAL_double:
3578. case LITERAL_void:
3579. case LITERAL_class:
3580. case LITERAL_struct:
3581. case LITERAL_union:
3582. case SCOPE:
3583. {
3584. declaration_specifiers();
3585. break;
3586. }
3587. default:
3588. {
3589. throw new NoViableAltException(LT(1), getFilename());
3590. }
3591. }
3592. }
3593. }
3594. }
3595. catch (RecognitionException pe) {
3596. synPredMatched203 = false;
3597. }
3598. rewind(_m203);
3599. inputState.guessing--;
3600. }
3601. if ( synPredMatched203 ) {
3602. id=qualified_id();
3603. if ( inputState.guessing==0 ) {
3604. declaratorID(id,CPPvariables.QI_FUN); m.directDeclarator(id, _td);
3605. }
3606. match(LPAREN);
3607. {
3608. switch ( LA(1)) {
3609. case LITERAL_typedef:
3610. case LITERAL_enum:
3611. case ID:
3612. case LITERAL_inline:
3613. case LITERAL_extern:
3614. case LITERAL__inline:
3615. case LITERAL___inline:
3616. case LITERAL_virtual:
3617. case LITERAL_explicit:
3618. case LITERAL_friend:
3619. case LITERAL__stdcall:
3620. case LITERAL___stdcall:
3621. case LITERAL__declspec:
3622. case LITERAL___declspec:
3623. case LPAREN:
3624. case LITERAL_typename:
3625. case LITERAL_auto:
3626. case LITERAL_register:
3627. case LITERAL_static:
3628. case LITERAL_mutable:
3629. case LITERAL_const:
3630. case LITERAL_const_cast:
3631. case LITERAL_volatile:
3632. case LITERAL_char:
3633. case LITERAL_wchar_t:
3634. case LITERAL_bool:
3635. case LITERAL_short:
3636. case LITERAL_int:
3637. case 44:
3638. case 45:
3639. case 46:
3640. case LITERAL_long:
3641. case LITERAL_signed:
3642. case LITERAL_unsigned:
3643. case LITERAL_float:
3644. case LITERAL_double:
3645. case LITERAL_void:
3646. case LITERAL_class:
3647. case LITERAL_struct:
3648. case LITERAL_union:
3649. case OPERATOR:
3650. case LITERAL_this:
3651. case LITERAL_true:
3652. case LITERAL_false:
3653. case STAR:
3654. case AMPERSAND:
3655. case TILDE:
3656. case ELLIPSIS:
3657. case SCOPE:
3658. case LITERAL__cdecl:
3659. case LITERAL___cdecl:
3660. case LITERAL__near:
3661. case LITERAL___near:
3662. case LITERAL__far:
3663. case LITERAL___far:
3664. case LITERAL___interrupt:
3665. case LITERAL_pascal:
3666. case LITERAL__pascal:
3667. case LITERAL___pascal:
3668. {
3669. parameter_list();
3670. break;
3671. }
3672. case RPAREN:
3673. {
3674. break;
3675. }
3676. default:
3677. {
3678. throw new NoViableAltException(LT(1), getFilename());
3679. }
3680. }
3681. }
3682. match(RPAREN);
3683. {
3684. _loop206:
3685. do {
3686. if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL_volatile))) {
3687. type_qualifier();
3688. }
3689. else {
3690. break _loop206;
3691. }
3692.
3693. } while (true);
3694. }
3695. {
3696. switch ( LA(1)) {
3697. case LITERAL_throw:
3698. {
3699. exception_specification();
3700. break;
3701. }
3702. case LESSTHAN:
3703. case GREATERTHAN:
3704. case ID:
3705. case SEMICOLON:
3706. case RCURLY:
3707. case ASSIGNEQUAL:
3708. case COLON:
3709. case COMMA:
3710. case LITERAL__stdcall:
3711. case LITERAL___stdcall:
3712. case LPAREN:
3713. case RPAREN:
3714. case OPERATOR:
3715. case LITERAL_this:
3716. case LITERAL_true:
3717. case LITERAL_false:
3718. case STAR:
3719. case AMPERSAND:
3720. case LSQUARE:
3721. case RSQUARE:
3722. case TILDE:
3723. case ELLIPSIS:
3724. case TIMESEQUAL:
3725. case DIVIDEEQUAL:
3726. case MINUSEQUAL:
3727. case PLUSEQUAL:
3728. case MODEQUAL:
3729. case SHIFTLEFTEQUAL:
3730. case SHIFTRIGHTEQUAL:
3731. case BITWISEANDEQUAL:
3732. case BITWISEXOREQUAL:
3733. case BITWISEOREQUAL:
3734. case QUESTIONMARK:
3735. case OR:
3736. case AND:
3737. case BITWISEOR:
3738. case BITWISEXOR:
3739. case NOTEQUAL:
3740. case EQUAL:
3741. case LESSTHANOREQUALTO:
3742. case GREATERTHANOREQUALTO:
3743. case SHIFTLEFT:
3744. case SHIFTRIGHT:
3745. case PLUS:
3746. case MINUS:
3747. case DIVIDE:
3748. case MOD:
3749. case DOTMBR:
3750. case POINTERTOMBR:
3751. case SCOPE:
3752. case LITERAL__cdecl:
3753. case LITERAL___cdecl:
3754. case LITERAL__near:
3755. case LITERAL___near:
3756. case LITERAL__far:
3757. case LITERAL___far:
3758. case LITERAL___interrupt:
3759. case LITERAL_pascal:
3760. case LITERAL__pascal:
3761. case LITERAL___pascal:
3762. {
3763. break;
3764. }
3765. default:
3766. {
3767. throw new NoViableAltException(LT(1), getFilename());
3768. }
3769. }
3770. }
3771. }
3772. else {
3773. boolean synPredMatched209 = false;
3774. if (((_tokenSet_29.member(LA(1))) && (_tokenSet_16.member(LA(2))))) {
3775. int _m209 = mark();
3776. synPredMatched209 = true;
3777. inputState.guessing++;
3778. try {
3779. {
3780. qualified_id();
3781. match(LPAREN);
3782. qualified_id();
3783. }
3784. }
3785. catch (RecognitionException pe) {
3786. synPredMatched209 = false;
3787. }
3788. rewind(_m209);
3789. inputState.guessing--;
3790. }
3791. if ( synPredMatched209 ) {
3792. id=qualified_id();
3793. if ( inputState.guessing==0 ) {
3794. declaratorID(id,CPPvariables.QI_VAR);
3795. }
3796. match(LPAREN);
3797. expression_list();
3798. match(RPAREN);
3799. }
3800. else {
3801. boolean synPredMatched211 = false;
3802. if (((_tokenSet_29.member(LA(1))) && (_tokenSet_16.member(LA(2))))) {
3803. int _m211 = mark();
3804. synPredMatched211 = true;
3805. inputState.guessing++;
3806. try {
3807. {
3808. qualified_id();
3809. match(LSQUARE);
3810. }
3811. }
3812. catch (RecognitionException pe) {
3813. synPredMatched211 = false;
3814. }
3815. rewind(_m211);
3816. inputState.guessing--;
3817. }
3818. if ( synPredMatched211 ) {
3819. id=qualified_id();
3820. if ( inputState.guessing==0 ) {
3821.
3822. if (_td==true)
3823. declaratorID(id,CPPvariables.QI_TYPE);
3824. else
3825. declaratorID(id,CPPvariables.QI_VAR);
3826.
3827. }
3828. {
3829. int _cnt214=0;
3830. _loop214:
3831. do {
3832. if ((LA(1)==LSQUARE) && (_tokenSet_32.member(LA(2)))) {
3833. match(LSQUARE);
3834. {
3835. switch ( LA(1)) {
3836. case ID:
3837. case StringLiteral:
3838. case LITERAL__declspec:
3839. case LITERAL___declspec:
3840. case LPAREN:
3841. case LITERAL_const_cast:
3842. case LITERAL_char:
3843. case LITERAL_wchar_t:
3844. case LITERAL_bool:
3845. case LITERAL_short:
3846. case LITERAL_int:
3847. case 44:
3848. case 45:
3849. case 46:
3850. case LITERAL_long:
3851. case LITERAL_signed:
3852. case LITERAL_unsigned:
3853. case LITERAL_float:
3854. case LITERAL_double:
3855. case LITERAL_void:
3856. case OPERATOR:
3857. case LITERAL_this:
3858. case LITERAL_true:
3859. case LITERAL_false:
3860. case OCTALINT:
3861. case STAR:
3862. case AMPERSAND:
3863. case TILDE:
3864. case PLUS:
3865. case MINUS:
3866. case PLUSPLUS:
3867. case MINUSMINUS:
3868. case LITERAL_sizeof:
3869. case SCOPE:
3870. case LITERAL_dynamic_cast:
3871. case LITERAL_static_cast:
3872. case LITERAL_reinterpret_cast:
3873. case NOT:
3874. case LITERAL_new:
3875. case LITERAL_delete:
3876. case DECIMALINT:
3877. case HEXADECIMALINT:
3878. case CharLiteral:
3879. case FLOATONE:
3880. case FLOATTWO:
3881. {
3882. constant_expression();
3883. break;
3884. }
3885. case RSQUARE:
3886. {
3887. break;
3888. }
3889. default:
3890. {
3891. throw new NoViableAltException(LT(1), getFilename());
3892. }
3893. }
3894. }
3895. match(RSQUARE);
3896. }
3897. else {
3898. if ( _cnt214>=1 ) { break _loop214; } else {throw new NoViableAltException(LT(1), getFilenam...3899. }
3900.
3901. _cnt214++;
3902. } while (true);
3903. }
3904. }
3905. else if ((_tokenSet_29.member(LA(1))) && (_tokenSet_33.member(LA(2)))) {
3906. id=qualified_id();
3907. if ( inputState.guessing==0 ) {
3908.
3909. if (_td==true)
3910. declaratorID(id,CPPvariables.QI_TYPE);
3911. else
3912. declaratorID(id,CPPvariables.QI_VAR);
3913. m.directDeclarator(id, _td);
3914.
3915. }
3916. }
3917. else {
3918. throw new NoViableAltException(LT(1), getFilename());
3919. }
3920. }}}
3921. }
3922.
3923. public final void simple_type_specifier() throws RecognitionException, TokenStreamException {
3924.
3925. String s="";
3926. java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone();
3927. auxBitSet.or(CPPvariables.QI_CTOR);
3928. List sts = new ArrayList();
3929.
3930.
3931. {
3932. if (((LA(1)==ID||LA(1)==SCOPE))&&(qualifiedItemIsOneOf(auxBitSet,0))) {
3933. s=qualified_type();
3934. if ( inputState.guessing==0 ) {
3935. sts.add(s); m.simpleTypeSpecifier(sts);
3936. }
3937. }
3938. else if ((_tokenSet_34.member(LA(1)))) {
3939. {
3940. int _cnt129=0;
3941. _loop129:
3942. do {
3943. switch ( LA(1)) {
3944. case LITERAL_char:
3945. {
3946. match(LITERAL_char);
3947. if ( inputState.guessing==0 ) {
3948. sts.add("char");
3949. }
3950. break;
3951. }
3952. case LITERAL_wchar_t:
3953. {
3954. match(LITERAL_wchar_t);
3955. if ( inputState.guessing==0 ) {
3956. sts.add("wchar_t");
3957. }
3958. break;
3959. }
3960. case LITERAL_bool:
3961. {
3962. match(LITERAL_bool);
3963. if ( inputState.guessing==0 ) {
3964. sts.add("bool");
3965. }
3966. break;
3967. }
3968. case LITERAL_short:
3969. {
3970. match(LITERAL_short);
3971. if ( inputState.guessing==0 ) {
3972. sts.add("short");
3973. }
3974. break;
3975. }
3976. case LITERAL_int:
3977. {
3978. match(LITERAL_int);
3979. if ( inputState.guessing==0 ) {
3980. sts.add("int");
3981. }
3982. break;
3983. }
3984. case 44:
3985. case 45:
3986. {
3987. {
3988. switch ( LA(1)) {
3989. case 44:
3990. {
3991. match(44);
3992. break;
3993. }
3994. case 45:
3995. {
3996. match(45);
3997. break;
3998. }
3999. default:
4000. {
4001. throw new NoViableAltException(LT(1), getFilename());
4002. }
4003. }
4004. }
4005. if ( inputState.guessing==0 ) {
4006. sts.add("__int64");
4007. }
4008. break;
4009. }
4010. case 46:
4011. {
4012. match(46);
4013. if ( inputState.guessing==0 ) {
4014. sts.add("__w64");
4015. }
4016. break;
4017. }
4018. case LITERAL_long:
4019. {
4020. match(LITERAL_long);
4021. if ( inputState.guessing==0 ) {
4022. sts.add("long");
4023. }
4024. break;
4025. }
4026. case LITERAL_signed:
4027. {
4028. match(LITERAL_signed);
4029. if ( inputState.guessing==0 ) {
4030. sts.add("signed");
4031. }
4032. break;
4033. }
4034. case LITERAL_unsigned:
4035. {
4036. match(LITERAL_unsigned);
4037. if ( inputState.guessing==0 ) {
4038. sts.add("unsigned");
4039. }
4040. break;
4041. }
4042. case LITERAL_float:
4043. {
4044. match(LITERAL_float);
4045. if ( inputState.guessing==0 ) {
4046. sts.add("float");
4047. }
4048. break;
4049. }
4050. case LITERAL_double:
4051. {
4052. match(LITERAL_double);
4053. if ( inputState.guessing==0 ) {
4054. sts.add("double");
4055. }
4056. break;
4057. }
4058. case LITERAL_void:
4059. {
4060. match(LITERAL_void);
4061. if ( inputState.guessing==0 ) {
4062. sts.add("void");
4063. }
4064. break;
4065. }
4066. case LITERAL__declspec:
4067. case LITERAL___declspec:
4068. {
4069. {
4070. switch ( LA(1)) {
4071. case LITERAL__declspec:
4072. {
4073. match(LITERAL__declspec);
4074. break;
4075. }
4076. case LITERAL___declspec:
4077. {
4078. match(LITERAL___declspec);
4079. break;
4080. }
4081. default:
4082. {
4083. throw new NoViableAltException(LT(1), getFilename());
4084. }
4085. }
4086. }
4087. match(LPAREN);
4088. match(ID);
4089. match(RPAREN);
4090. break;
4091. }
4092. default:
4093. {
4094. if ( _cnt129>=1 ) { break _loop129; } else {throw new NoViableAltException(LT(1), getFilename()...4095. }
4096. }
4097. _cnt129++;
4098. } while (true);
4099. }
4100. if ( inputState.guessing==0 ) {
4101. m.simpleTypeSpecifier(sts);
4102. }
4103. }
4104. else {
4105. throw new NoViableAltException(LT(1), getFilename());
4106. }
4107.
4108. }
4109. }
4110.
4111. public final void class_specifier() throws RecognitionException, TokenStreamException {
4112.
4113. String saveClass="";String id="";String type="";
4114.
4115. {
4116. switch ( LA(1)) {
4117. case LITERAL_class:
4118. {
4119. match(LITERAL_class);
4120. if ( inputState.guessing==0 ) {
4121. type=CPPvariables.OT_CLASS;
4122. }
4123. break;
4124. }
4125. case LITERAL_struct:
4126. {
4127. match(LITERAL_struct);
4128. if ( inputState.guessing==0 ) {
4129. type=CPPvariables.OT_STRUCT;
4130. }
4131. break;
4132. }
4133. case LITERAL_union:
4134. {
4135. match(LITERAL_union);
4136. if ( inputState.guessing==0 ) {
4137. type=CPPvariables.OT_UNION;
4138. }
4139. break;
4140. }
4141. default:
4142. {
4143. throw new NoViableAltException(LT(1), getFilename());
4144. }
4145. }
4146. }
4147. {
4148. switch ( LA(1)) {
4149. case ID:
4150. case OPERATOR:
4151. case LITERAL_this:
4152. case LITERAL_true:
4153. case LITERAL_false:
4154. case SCOPE:
4155. {
4156. id=qualified_id();
4157. {
4158. if ((LA(1)==LCURLY||LA(1)==COLON) && (_tokenSet_35.member(LA(2)))) {
4159. if ( inputState.guessing==0 ) {
4160. saveClass = enclosingClass;
4161. enclosingClass = id;
4162.
4163. }
4164. if ( inputState.guessing==0 ) {
4165. m.beginClassDefinition(type, id);
4166. }
4167. {
4168. switch ( LA(1)) {
4169. case COLON:
4170. {
4171. base_clause();
4172. break;
4173. }
4174. case LCURLY:
4175. {
4176. break;
4177. }
4178. default:
4179. {
4180. throw new NoViableAltException(LT(1), getFilename());
4181. }
4182. }
4183. }
4184. match(LCURLY);
4185. if ( inputState.guessing==0 ) {
4186.
4187. if(!symbols.containsKey(id))
4188. symbols.put(id,type);
4189.
4190. }
4191. {
4192. _loop138:
4193. do {
4194. if ((_tokenSet_36.member(LA(1)))) {
4195. member_declaration();
4196. }
4197. else {
4198. break _loop138;
4199. }
4200.
4201. } while (true);
4202. }
4203. if ( inputState.guessing==0 ) {
4204. m.endClassDefinition();
4205. }
4206. match(RCURLY);
4207. if ( inputState.guessing==0 ) {
4208. enclosingClass = saveClass;
4209. }
4210. }
4211. else if ((_tokenSet_37.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
4212. if ( inputState.guessing==0 ) {
4213.
4214.
4215. String auxName=id;
4216. int pos = auxName.indexOf("::");
4217. while(pos>=0)
4218. {
4219. if(!symbols.containsKey(auxName.substring(0,pos)))
4220. symbols.put(auxName.substring(0,pos),type);
4221. auxName=auxName.substring(pos+2,auxName.length());
4222. pos=auxName.indexOf("::");
4223. }
4224. if(!symbols.containsKey(auxName))
4225. symbols.put(auxName,type);
4226.
4227. }
4228. }
4229. else {
4230. throw new NoViableAltException(LT(1), getFilename());
4231. }
4232.
4233. }
4234. break;
4235. }
4236. case LCURLY:
4237. {
4238. match(LCURLY);
4239. if ( inputState.guessing==0 ) {
4240. id="anonymous";
4241. saveClass = enclosingClass; enclosingClass = "anonymous";
4242. if(!symbols.containsKey(id))
4243. symbols.put(id,type);
4244.
4245. }
4246. {
4247. _loop140:
4248. do {
4249. if ((_tokenSet_36.member(LA(1)))) {
4250. member_declaration();
4251. }
4252. else {
4253. break _loop140;
4254. }
4255.
4256. } while (true);
4257. }
4258. match(RCURLY);
4259. if ( inputState.guessing==0 ) {
4260. enclosingClass = saveClass;
4261. }
4262. break;
4263. }
4264. default:
4265. {
4266. throw new NoViableAltException(LT(1), getFilename());
4267. }
4268. }
4269. }
4270. }
4271.
4272. public final String qualified_type() throws RecognitionException, TokenStreamException {
4273. String q="";
4274.
4275. Token id = null;
4276. String s=""; String qitem="";
4277.
4278. s=scope_override();
4279. id = LT(1);
4280. match(ID);
4281. {
4282. if ((LA(1)==LESSTHAN) && (_tokenSet_24.member(LA(2)))) {
4283. match(LESSTHAN);
4284. template_argument_list();
4285. match(GREATERTHAN);
4286. }
4287. else if ((_tokenSet_25.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
4288. }
4289. else {
4290. throw new NoViableAltException(LT(1), getFilename());
4291. }
4292.
4293. }
4294. if ( inputState.guessing==0 ) {
4295.
4296. qitem=s;
4297. qitem=qitem+id.getText();
4298. q=qitem;
4299.
4300. }
4301. return q;
4302. }
4303.
4304. public final void template_argument_list() throws RecognitionException, TokenStreamException {
4305.
4306.
4307. template_argument();
4308. {
4309. _loop304:
4310. do {
4311. if ((LA(1)==COMMA)) {
4312. match(COMMA);
4313. template_argument();
4314. }
4315. else {
4316. break _loop304;
4317. }
4318.
4319. } while (true);
4320. }
4321. }
4322.
4323. public final void base_clause() throws RecognitionException, TokenStreamException {
4324.
4325.
4326. match(COLON);
4327. base_specifier();
4328. {
4329. _loop170:
4330. do {
4331. if ((LA(1)==COMMA)) {
4332. match(COMMA);
4333. base_specifier();
4334. }
4335. else {
4336. break _loop170;
4337. }
4338.
4339. } while (true);
4340. }
4341. }
4342.
4343. public final void enumerator_list() throws RecognitionException, TokenStreamException {
4344.
4345.
4346. enumerator();
4347. {
4348. _loop146:
4349. do {
4350. if ((LA(1)==COMMA)) {
4351. match(COMMA);
4352. enumerator();
4353. }
4354. else {
4355. break _loop146;
4356. }
4357.
4358. } while (true);
4359. }
4360. }
4361.
4362. public final void enumerator() throws RecognitionException, TokenStreamException {
4363.
4364. Token id = null;
4365.
4366. id = LT(1);
4367. match(ID);
4368. {
4369. switch ( LA(1)) {
4370. case ASSIGNEQUAL:
4371. {
4372. match(ASSIGNEQUAL);
4373. constant_expression();
4374. break;
4375. }
4376. case RCURLY:
4377. case COMMA:
4378. {
4379. break;
4380. }
4381. default:
4382. {
4383. throw new NoViableAltException(LT(1), getFilename());
4384. }
4385. }
4386. }
4387. }
4388.
4389. public final void constant_expression() throws RecognitionException, TokenStreamException {
4390.
4391.
4392. conditional_expression();
4393. }
4394.
4395. public final void optor() throws RecognitionException, TokenStreamException {
4396.
4397.
4398. switch ( LA(1)) {
4399. case LITERAL_new:
4400. {
4401. match(LITERAL_new);
4402. {
4403. if ((LA(1)==LSQUARE) && (LA(2)==RSQUARE)) {
4404. match(LSQUARE);
4405. match(RSQUARE);
4406. }
4407. else if ((_tokenSet_38.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
4408. }
4409. else {
4410. throw new NoViableAltException(LT(1), getFilename());
4411. }
4412.
4413. }
4414. break;
4415. }
4416. case LITERAL_delete:
4417. {
4418. match(LITERAL_delete);
4419. {
4420. if ((LA(1)==LSQUARE) && (LA(2)==RSQUARE)) {
4421. match(LSQUARE);
4422. match(RSQUARE);
4423. }
4424. else if ((_tokenSet_38.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
4425. }
4426. else {
4427. throw new NoViableAltException(LT(1), getFilename());
4428. }
4429.
4430. }
4431. break;
4432. }
4433. case LPAREN:
4434. {
4435. match(LPAREN);
4436. match(RPAREN);
4437. break;
4438. }
4439. case LSQUARE:
4440. {
4441. match(LSQUARE);
4442. match(RSQUARE);
4443. break;
4444. }
4445. case LESSTHAN:
4446. case GREATERTHAN:
4447. case ASSIGNEQUAL:
4448. case COMMA:
4449. case STAR:
4450. case AMPERSAND:
4451. case TILDE:
4452. case TIMESEQUAL:
4453. case DIVIDEEQUAL:
4454. case MINUSEQUAL:
4455. case PLUSEQUAL:
4456. case MODEQUAL:
4457. case SHIFTLEFTEQUAL:
4458. case SHIFTRIGHTEQUAL:
4459. case BITWISEANDEQUAL:
4460. case BITWISEXOREQUAL:
4461. case BITWISEOREQUAL:
4462. case OR:
4463. case AND:
4464. case BITWISEOR:
4465. case BITWISEXOR:
4466. case NOTEQUAL:
4467. case EQUAL:
4468. case LESSTHANOREQUALTO:
4469. case GREATERTHANOREQUALTO:
4470. case SHIFTLEFT:
4471. case SHIFTRIGHT:
4472. case PLUS:
4473. case MINUS:
4474. case DIVIDE:
4475. case MOD:
4476. case POINTERTOMBR:
4477. case PLUSPLUS:
4478. case MINUSMINUS:
4479. case POINTERTO:
4480. case NOT:
4481. {
4482. optor_simple_tokclass();
4483. break;
4484. }
4485. default:
4486. {
4487. throw new NoViableAltException(LT(1), getFilename());
4488. }
4489. }
4490. }
4491.
4492. public final void typeID() throws RecognitionException, TokenStreamException {
4493.
4494.
4495. if (!(isTypeName(LT(1).getText())))
4496. throw new SemanticException("isTypeName(LT(1).getText())");
4497. match(ID);
4498. }
4499.
4500. public final void init_declarator() throws RecognitionException, TokenStreamException {
4501.
4502.
4503. declarator();
4504. {
4505. switch ( LA(1)) {
4506. case ASSIGNEQUAL:
4507. {
4508. match(ASSIGNEQUAL);
4509. initializer();
4510. break;
4511. }
4512. case LPAREN:
4513. {
4514. match(LPAREN);
4515. expression_list();
4516. match(RPAREN);
4517. break;
4518. }
4519. case SEMICOLON:
4520. case COMMA:
4521. {
4522. break;
4523. }
4524. default:
4525. {
4526. throw new NoViableAltException(LT(1), getFilename());
4527. }
4528. }
4529. }
4530. }
4531.
4532. public final void declarator() throws RecognitionException, TokenStreamException {
4533.
4534.
4535. boolean synPredMatched199 = false;
4536. if (((_tokenSet_13.member(LA(1))) && (_tokenSet_39.member(LA(2))))) {
4537. int _m199 = mark();
4538. synPredMatched199 = true;
4539. inputState.guessing++;
4540. try {
4541. {
4542. ptr_operator();
4543. }
4544. }
4545. catch (RecognitionException pe) {
4546. synPredMatched199 = false;
4547. }
4548. rewind(_m199);
4549. inputState.guessing--;
4550. }
4551. if ( synPredMatched199 ) {
4552. ptr_operator();
4553. declarator();
4554. }
4555. else if ((_tokenSet_40.member(LA(1))) && (_tokenSet_41.member(LA(2)))) {
4556. direct_declarator();
4557. }
4558. else {
4559. throw new NoViableAltException(LT(1), getFilename());
4560. }
4561.
4562. }
4563.
4564. public final void initializer() throws RecognitionException, TokenStreamException {
4565.
4566.
4567. if ( inputState.guessing==0 ) {
4568. m.beginInitializer();
4569. }
4570. {
4571. switch ( LA(1)) {
4572. case ID:
4573. case StringLiteral:
4574. case LITERAL__declspec:
4575. case LITERAL___declspec:
4576. case LPAREN:
4577. case LITERAL_const_cast:
4578. case LITERAL_char:
4579. case LITERAL_wchar_t:
4580. case LITERAL_bool:
4581. case LITERAL_short:
4582. case LITERAL_int:
4583. case 44:
4584. case 45:
4585. case 46:
4586. case LITERAL_long:
4587. case LITERAL_signed:
4588. case LITERAL_unsigned:
4589. case LITERAL_float:
4590. case LITERAL_double:
4591. case LITERAL_void:
4592. case OPERATOR:
4593. case LITERAL_this:
4594. case LITERAL_true:
4595. case LITERAL_false:
4596. case OCTALINT:
4597. case STAR:
4598. case AMPERSAND:
4599. case TILDE:
4600. case PLUS:
4601. case MINUS:
4602. case PLUSPLUS:
4603. case MINUSMINUS:
4604. case LITERAL_sizeof:
4605. case SCOPE:
4606. case LITERAL_dynamic_cast:
4607. case LITERAL_static_cast:
4608. case LITERAL_reinterpret_cast:
4609. case NOT:
4610. case LITERAL_new:
4611. case LITERAL_delete:
4612. case DECIMALINT:
4613. case HEXADECIMALINT:
4614. case CharLiteral:
4615. case FLOATONE:
4616. case FLOATTWO:
4617. {
4618. remainder_expression();
4619. break;
4620. }
4621. case LCURLY:
4622. {
4623. match(LCURLY);
4624. initializer();
4625. {
4626. _loop162:
4627. do {
4628. if ((LA(1)==COMMA)) {
4629. match(COMMA);
4630. initializer();
4631. }
4632. else {
4633. break _loop162;
4634. }
4635.
4636. } while (true);
4637. }
4638. match(RCURLY);
4639. break;
4640. }
4641. default:
4642. {
4643. throw new NoViableAltException(LT(1), getFilename());
4644. }
4645. }
4646. }
4647. if ( inputState.guessing==0 ) {
4648. m.endInitializer();
4649. }
4650. }
4651.
4652. public final void expression_list() throws RecognitionException, TokenStreamException {
4653.
4654.
4655. assignment_expression();
4656. {
4657. _loop465:
4658. do {
4659. if ((LA(1)==COMMA)) {
4660. match(COMMA);
4661. assignment_expression();
4662. }
4663. else {
4664. break _loop465;
4665. }
4666.
4667. } while (true);
4668. }
4669. }
4670.
4671. public final void remainder_expression() throws RecognitionException, TokenStreamException {
4672.
4673.
4674. {
4675. boolean synPredMatched355 = false;
4676. if (((_tokenSet_42.member(LA(1))) && (_tokenSet_43.member(LA(2))))) {
4677. int _m355 = mark();
4678. synPredMatched355 = true;
4679. inputState.guessing++;
4680. try {
4681. {
4682. conditional_expression();
4683. {
4684. switch ( LA(1)) {
4685. case COMMA:
4686. {
4687. match(COMMA);
4688. break;
4689. }
4690. case SEMICOLON:
4691. {
4692. match(SEMICOLON);
4693. break;
4694. }
4695. case RPAREN:
4696. {
4697. match(RPAREN);
4698. break;
4699. }
4700. default:
4701. {
4702. throw new NoViableAltException(LT(1), getFilename());
4703. }
4704. }
4705. }
4706. }
4707. }
4708. catch (RecognitionException pe) {
4709. synPredMatched355 = false;
4710. }
4711. rewind(_m355);
4712. inputState.guessing--;
4713. }
4714. if ( synPredMatched355 ) {
4715. assignment_expression();
4716. }
4717. else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_43.member(LA(2)))) {
4718. assignment_expression();
4719. }
4720. else {
4721. throw new NoViableAltException(LT(1), getFilename());
4722. }
4723.
4724. }
4725. }
4726.
4727. public final void base_specifier() throws RecognitionException, TokenStreamException {
4728.
4729. String qt=""; m.beginBaseSpecifier();
4730.
4731. {
4732. switch ( LA(1)) {
4733. case LITERAL_virtual:
4734. {
4735. match(LITERAL_virtual);
4736. {
4737. switch ( LA(1)) {
4738. case LITERAL_public:
4739. case LITERAL_protected:
4740. case LITERAL_private:
4741. {
4742. access_specifier();
4743. break;
4744. }
4745. case ID:
4746. case SCOPE:
4747. {
4748. break;
4749. }
4750. default:
4751. {
4752. throw new NoViableAltException(LT(1), getFilename());
4753. }
4754. }
4755. }
4756. qt=qualified_type();
4757. if ( inputState.guessing==0 ) {
4758. m.baseSpecifier(qt, true);
4759. }
4760. break;
4761. }
4762. case ID:
4763. case SCOPE:
4764. {
4765. qt=qualified_type();
4766. if ( inputState.guessing==0 ) {
4767. m.baseSpecifier(qt, false);
4768. }
4769. break;
4770. }
4771. default:
4772. if (((LA(1) >= LITERAL_public && LA(1) <= LITERAL_private)) && (LA(2)==LITERAL_virtual)) {
4773. access_specifier();
4774. match(LITERAL_virtual);
4775. qt=qualified_type();
4776. if ( inputState.guessing==0 ) {
4777. m.baseSpecifier(qt, true);
4778. }
4779. }
4780. else if (((LA(1) >= LITERAL_public && LA(1) <= LITERAL_private)) && (LA(2)==ID||LA(2)==SCOPE)) {
...4781. access_specifier();
4782. qt=qualified_type();
4783. if ( inputState.guessing==0 ) {
4784. m.baseSpecifier(qt, false);
4785. }
4786. }
4787. else {
4788. throw new NoViableAltException(LT(1), getFilename());
4789. }
4790. }
4791. }
4792. if ( inputState.guessing==0 ) {
4793. m.endBaseSpecifier();
4794. }
4795. }
4796.
4797. public final void member_declarator() throws RecognitionException, TokenStreamException {
4798.
4799. m.beginMemberDeclarator();
4800.
4801. {
4802. boolean synPredMatched185 = false;
4803. if (((LA(1)==ID||LA(1)==COLON) && (_tokenSet_44.member(LA(2))))) {
4804. int _m185 = mark();
4805. synPredMatched185 = true;
4806. inputState.guessing++;
4807. try {
4808. {
4809. {
4810. switch ( LA(1)) {
4811. case ID:
4812. {
4813. match(ID);
4814. break;
4815. }
4816. case COLON:
4817. {
4818. break;
4819. }
4820. default:
4821. {
4822. throw new NoViableAltException(LT(1), getFilename());
4823. }
4824. }
4825. }
4826. match(COLON);
4827. constant_expression();
4828. }
4829. }
4830. catch (RecognitionException pe) {
4831. synPredMatched185 = false;
4832. }
4833. rewind(_m185);
4834. inputState.guessing--;
4835. }
4836. if ( synPredMatched185 ) {
4837. {
4838. switch ( LA(1)) {
4839. case ID:
4840. {
4841. match(ID);
4842. break;
4843. }
4844. case COLON:
4845. {
4846. break;
4847. }
4848. default:
4849. {
4850. throw new NoViableAltException(LT(1), getFilename());
4851. }
4852. }
4853. }
4854. match(COLON);
4855. constant_expression();
4856. }
4857. else if ((_tokenSet_45.member(LA(1))) && (_tokenSet_46.member(LA(2)))) {
4858. declarator();
4859. }
4860. else {
4861. throw new NoViableAltException(LT(1), getFilename());
4862. }
4863.
4864. }
4865. if ( inputState.guessing==0 ) {
4866. m.endMemberDeclarator();
4867. }
4868. }
4869.
4870. public final void template_parameter_list() throws RecognitionException, TokenStreamException {
4871.
4872.
4873. template_parameter();
4874. {
4875. _loop293:
4876. do {
4877. if ((LA(1)==COMMA)) {
4878. match(COMMA);
4879. template_parameter();
4880. }
4881. else {
4882. break _loop293;
4883. }
4884.
4885. } while (true);
4886. }
4887. }
4888.
4889. public final void parameter_list() throws RecognitionException, TokenStreamException {
4890.
4891.
4892. parameter_declaration_list();
4893. {
4894. switch ( LA(1)) {
4895. case ELLIPSIS:
4896. {
4897. match(ELLIPSIS);
4898. break;
4899. }
4900. case RPAREN:
4901. {
4902. break;
4903. }
4904. default:
4905. {
4906. throw new NoViableAltException(LT(1), getFilename());
4907. }
4908. }
4909. }
4910. }
4911.
4912. public final void exception_specification() throws RecognitionException, TokenStreamException {
4913.
4914. String so="";
4915.
4916. match(LITERAL_throw);
4917. match(LPAREN);
4918. {
4919. switch ( LA(1)) {
4920. case ID:
4921. case RPAREN:
4922. case SCOPE:
4923. {
4924. {
4925. switch ( LA(1)) {
4926. case ID:
4927. case SCOPE:
4928. {
4929. so=scope_override();
4930. match(ID);
4931. {
4932. _loop289:
4933. do {
4934. if ((LA(1)==COMMA)) {
4935. match(COMMA);
4936. so=scope_override();
4937. match(ID);
4938. }
4939. else {
4940. break _loop289;
4941. }
4942.
4943. } while (true);
4944. }
4945. break;
4946. }
4947. case RPAREN:
4948. {
4949. break;
4950. }
4951. default:
4952. {
4953. throw new NoViableAltException(LT(1), getFilename());
4954. }
4955. }
4956. }
4957. break;
4958. }
4959. case ELLIPSIS:
4960. {
4961. match(ELLIPSIS);
4962. break;
4963. }
4964. default:
4965. {
4966. throw new NoViableAltException(LT(1), getFilename());
4967. }
4968. }
4969. }
4970. match(RPAREN);
4971. }
4972.
4973. public final void cv_qualifier_seq() throws RecognitionException, TokenStreamException {
4974.
4975.
4976. {
4977. _loop196:
4978. do {
4979. if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL_volatile))) {
4980. type_qualifier();
4981. }
4982. else {
4983. break _loop196;
4984. }
4985.
4986. } while (true);
4987. }
4988. }
4989.
4990. public final void ptr_operator() throws RecognitionException, TokenStreamException {
4991.
4992.
4993. if ( inputState.guessing==0 ) {
4994. m.beginPtrOperator();
4995. }
4996. {
4997. switch ( LA(1)) {
4998. case AMPERSAND:
4999. {
5000. match(AMPERSAND);
5001. if ( inputState.guessing==0 ) {
5002. m.ptrOperator("&");
5003. }
5004. break;
5005. }
5006. case LITERAL__cdecl:
5007. case LITERAL___cdecl:
5008. {
5009. {
5010. switch ( LA(1)) {
5011. case LITERAL__cdecl:
5012. {
5013. match(LITERAL__cdecl);
5014. break;
5015. }
5016. case LITERAL___cdecl:
5017. {
5018. match(LITERAL___cdecl);
5019. break;
5020. }
5021. default:
5022. {
5023. throw new NoViableAltException(LT(1), getFilename());
5024. }
5025. }
5026. }
5027. break;
5028. }
5029. case LITERAL__near:
5030. case LITERAL___near:
5031. {
5032. {
5033. switch ( LA(1)) {
5034. case LITERAL__near:
5035. {
5036. match(LITERAL__near);
5037. break;
5038. }
5039. case LITERAL___near:
5040. {
5041. match(LITERAL___near);
5042. break;
5043. }
5044. default:
5045. {
5046. throw new NoViableAltException(LT(1), getFilename());
5047. }
5048. }
5049. }
5050. break;
5051. }
5052. case LITERAL__far:
5053. case LITERAL___far:
5054. {
5055. {
5056. switch ( LA(1)) {
5057. case LITERAL__far:
5058. {
5059. match(LITERAL__far);
5060. break;
5061. }
5062. case LITERAL___far:
5063. {
5064. match(LITERAL___far);
5065. break;
5066. }
5067. default:
5068. {
5069. throw new NoViableAltException(LT(1), getFilename());
5070. }
5071. }
5072. }
5073. break;
5074. }
5075. case LITERAL___interrupt:
5076. {
5077. match(LITERAL___interrupt);
5078. break;
5079. }
5080. case LITERAL_pascal:
5081. case LITERAL__pascal:
5082. case LITERAL___pascal:
5083. {
5084. {
5085. switch ( LA(1)) {
5086. case LITERAL_pascal:
5087. {
5088. match(LITERAL_pascal);
5089. break;
5090. }
5091. case LITERAL__pascal:
5092. {
5093. match(LITERAL__pascal);
5094. break;
5095. }
5096. case LITERAL___pascal:
5097. {
5098. match(LITERAL___pascal);
5099. break;
5100. }
5101. default:
5102. {
5103. throw new NoViableAltException(LT(1), getFilename());
5104. }
5105. }
5106. }
5107. break;
5108. }
5109. case LITERAL__stdcall:
5110. case LITERAL___stdcall:
5111. {
5112. {
5113. switch ( LA(1)) {
5114. case LITERAL__stdcall:
5115. {
5116. match(LITERAL__stdcall);
5117. break;
5118. }
5119. case LITERAL___stdcall:
5120. {
5121. match(LITERAL___stdcall);
5122. break;
5123. }
5124. default:
5125. {
5126. throw new NoViableAltException(LT(1), getFilename());
5127. }
5128. }
5129. }
5130. break;
5131. }
5132. case ID:
5133. case STAR:
5134. case SCOPE:
5135. {
5136. ptr_to_member();
5137. break;
5138. }
5139. default:
5140. {
5141. throw new NoViableAltException(LT(1), getFilename());
5142. }
5143. }
5144. }
5145. if ( inputState.guessing==0 ) {
5146. m.endPtrOperator();
5147. }
5148. }
5149.
5150. public final void declarator_suffixes() throws RecognitionException, TokenStreamException {
5151.
5152. java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone(); auxBitSet.or(CPPvariabl...5153.
5154. {
5155. if ((LA(1)==LSQUARE)) {
5156. {
5157. int _cnt220=0;
5158. _loop220:
5159. do {
5160. if ((LA(1)==LSQUARE) && (_tokenSet_32.member(LA(2)))) {
5161. match(LSQUARE);
5162. {
5163. switch ( LA(1)) {
5164. case ID:
5165. case StringLiteral:
5166. case LITERAL__declspec:
5167. case LITERAL___declspec:
5168. case LPAREN:
5169. case LITERAL_const_cast:
5170. case LITERAL_char:
5171. case LITERAL_wchar_t:
5172. case LITERAL_bool:
5173. case LITERAL_short:
5174. case LITERAL_int:
5175. case 44:
5176. case 45:
5177. case 46:
5178. case LITERAL_long:
5179. case LITERAL_signed:
5180. case LITERAL_unsigned:
5181. case LITERAL_float:
5182. case LITERAL_double:
5183. case LITERAL_void:
5184. case OPERATOR:
5185. case LITERAL_this:
5186. case LITERAL_true:
5187. case LITERAL_false:
5188. case OCTALINT:
5189. case STAR:
5190. case AMPERSAND:
5191. case TILDE:
5192. case PLUS:
5193. case MINUS:
5194. case PLUSPLUS:
5195. case MINUSMINUS:
5196. case LITERAL_sizeof:
5197. case SCOPE:
5198. case LITERAL_dynamic_cast:
5199. case LITERAL_static_cast:
5200. case LITERAL_reinterpret_cast:
5201. case NOT:
5202. case LITERAL_new:
5203. case LITERAL_delete:
5204. case DECIMALINT:
5205. case HEXADECIMALINT:
5206. case CharLiteral:
5207. case FLOATONE:
5208. case FLOATTWO:
5209. {
5210. constant_expression();
5211. break;
5212. }
5213. case RSQUARE:
5214. {
5215. break;
5216. }
5217. default:
5218. {
5219. throw new NoViableAltException(LT(1), getFilename());
5220. }
5221. }
5222. }
5223. match(RSQUARE);
5224. }
5225. else {
5226. if ( _cnt220>=1 ) { break _loop220; } else {throw new NoViableAltException(LT(1), getFilename()...5227. }
5228.
5229. _cnt220++;
5230. } while (true);
5231. }
5232. }
5233. else if (((LA(1)==LPAREN))&&((!((LA(1)==LPAREN)&&(LA(2)==ID))||(qualifiedItemIsOneOf(auxBitSet,1))...5234. match(LPAREN);
5235. {
5236. switch ( LA(1)) {
5237. case LITERAL_typedef:
5238. case LITERAL_enum:
5239. case ID:
5240. case LITERAL_inline:
5241. case LITERAL_extern:
5242. case LITERAL__inline:
5243. case LITERAL___inline:
5244. case LITERAL_virtual:
5245. case LITERAL_explicit:
5246. case LITERAL_friend:
5247. case LITERAL__stdcall:
5248. case LITERAL___stdcall:
5249. case LITERAL__declspec:
5250. case LITERAL___declspec:
5251. case LPAREN:
5252. case LITERAL_typename:
5253. case LITERAL_auto:
5254. case LITERAL_register:
5255. case LITERAL_static:
5256. case LITERAL_mutable:
5257. case LITERAL_const:
5258. case LITERAL_const_cast:
5259. case LITERAL_volatile:
5260. case LITERAL_char:
5261. case LITERAL_wchar_t:
5262. case LITERAL_bool:
5263. case LITERAL_short:
5264. case LITERAL_int:
5265. case 44:
5266. case 45:
5267. case 46:
5268. case LITERAL_long:
5269. case LITERAL_signed:
5270. case LITERAL_unsigned:
5271. case LITERAL_float:
5272. case LITERAL_double:
5273. case LITERAL_void:
5274. case LITERAL_class:
5275. case LITERAL_struct:
5276. case LITERAL_union:
5277. case OPERATOR:
5278. case LITERAL_this:
5279. case LITERAL_true:
5280. case LITERAL_false:
5281. case STAR:
5282. case AMPERSAND:
5283. case TILDE:
5284. case ELLIPSIS:
5285. case SCOPE:
5286. case LITERAL__cdecl:
5287. case LITERAL___cdecl:
5288. case LITERAL__near:
5289. case LITERAL___near:
5290. case LITERAL__far:
5291. case LITERAL___far:
5292. case LITERAL___interrupt:
5293. case LITERAL_pascal:
5294. case LITERAL__pascal:
5295. case LITERAL___pascal:
5296. {
5297. parameter_list();
5298. break;
5299. }
5300. case RPAREN:
5301. {
5302. break;
5303. }
5304. default:
5305. {
5306. throw new NoViableAltException(LT(1), getFilename());
5307. }
5308. }
5309. }
5310. match(RPAREN);
5311. {
5312. _loop223:
5313. do {
5314. if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL_volatile))) {
5315. type_qualifier();
5316. }
5317. else {
5318. break _loop223;
5319. }
5320.
5321. } while (true);
5322. }
5323. {
5324. switch ( LA(1)) {
5325. case LITERAL_throw:
5326. {
5327. exception_specification();
5328. break;
5329. }
5330. case LESSTHAN:
5331. case GREATERTHAN:
5332. case ID:
5333. case SEMICOLON:
5334. case RCURLY:
5335. case ASSIGNEQUAL:
5336. case COLON:
5337. case COMMA:
5338. case LITERAL__stdcall:
5339. case LITERAL___stdcall:
5340. case LPAREN:
5341. case RPAREN:
5342. case OPERATOR:
5343. case LITERAL_this:
5344. case LITERAL_true:
5345. case LITERAL_false:
5346. case STAR:
5347. case AMPERSAND:
5348. case LSQUARE:
5349. case RSQUARE:
5350. case TILDE:
5351. case ELLIPSIS:
5352. case TIMESEQUAL:
5353. case DIVIDEEQUAL:
5354. case MINUSEQUAL:
5355. case PLUSEQUAL:
5356. case MODEQUAL:
5357. case SHIFTLEFTEQUAL:
5358. case SHIFTRIGHTEQUAL:
5359. case BITWISEANDEQUAL:
5360. case BITWISEXOREQUAL:
5361. case BITWISEOREQUAL:
5362. case QUESTIONMARK:
5363. case OR:
5364. case AND:
5365. case BITWISEOR:
5366. case BITWISEXOR:
5367. case NOTEQUAL:
5368. case EQUAL:
5369. case LESSTHANOREQUALTO:
5370. case GREATERTHANOREQUALTO:
5371. case SHIFTLEFT:
5372. case SHIFTRIGHT:
5373. case PLUS:
5374. case MINUS:
5375. case DIVIDE:
5376. case MOD:
5377. case DOTMBR:
5378. case POINTERTOMBR:
5379. case SCOPE:
5380. case LITERAL__cdecl:
5381. case LITERAL___cdecl:
5382. case LITERAL__near:
5383. case LITERAL___near:
5384. case LITERAL__far:
5385. case LITERAL___far:
5386. case LITERAL___interrupt:
5387. case LITERAL_pascal:
5388. case LITERAL__pascal:
5389. case LITERAL___pascal:
5390. {
5391. break;
5392. }
5393. default:
5394. {
5395. throw new NoViableAltException(LT(1), getFilename());
5396. }
5397. }
5398. }
5399. }
5400. else {
5401. throw new NoViableAltException(LT(1), getFilename());
5402. }
5403.
5404. }
5405. }
5406.
5407. public final void function_direct_declarator() throws RecognitionException, TokenStreamException {
...5408.
5409. String q="";
5410.
5411. {
5412. switch ( LA(1)) {
5413. case LPAREN:
5414. {
5415. match(LPAREN);
5416. q=qualified_id();
5417. if ( inputState.guessing==0 ) {
5418.
5419. declaratorID(q,CPPvariables.QI_FUN);
5420.
5421. }
5422. match(RPAREN);
5423. break;
5424. }
5425. case ID:
5426. case OPERATOR:
5427. case LITERAL_this:
5428. case LITERAL_true:
5429. case LITERAL_false:
5430. case SCOPE:
5431. {
5432. q=qualified_id();
5433. if ( inputState.guessing==0 ) {
5434.
5435. declaratorID(q,CPPvariables.QI_FUN);
5436.
5437. }
5438. break;
5439. }
5440. default:
5441. {
5442. throw new NoViableAltException(LT(1), getFilename());
5443. }
5444. }
5445. }
5446. if ( inputState.guessing==0 ) {
5447. m.functionDirectDeclarator(q);
5448. }
5449. match(LPAREN);
5450. {
5451. switch ( LA(1)) {
5452. case LITERAL_typedef:
5453. case LITERAL_enum:
5454. case ID:
5455. case LITERAL_inline:
5456. case LITERAL_extern:
5457. case LITERAL__inline:
5458. case LITERAL___inline:
5459. case LITERAL_virtual:
5460. case LITERAL_explicit:
5461. case LITERAL_friend:
5462. case LITERAL__stdcall:
5463. case LITERAL___stdcall:
5464. case LITERAL__declspec:
5465. case LITERAL___declspec:
5466. case LPAREN:
5467. case LITERAL_typename:
5468. case LITERAL_auto:
5469. case LITERAL_register:
5470. case LITERAL_static:
5471. case LITERAL_mutable:
5472. case LITERAL_const:
5473. case LITERAL_const_cast:
5474. case LITERAL_volatile:
5475. case LITERAL_char:
5476. case LITERAL_wchar_t:
5477. case LITERAL_bool:
5478. case LITERAL_short:
5479. case LITERAL_int:
5480. case 44:
5481. case 45:
5482. case 46:
5483. case LITERAL_long:
5484. case LITERAL_signed:
5485. case LITERAL_unsigned:
5486. case LITERAL_float:
5487. case LITERAL_double:
5488. case LITERAL_void:
5489. case LITERAL_class:
5490. case LITERAL_struct:
5491. case LITERAL_union:
5492. case OPERATOR:
5493. case LITERAL_this:
5494. case LITERAL_true:
5495. case LITERAL_false:
5496. case STAR:
5497. case AMPERSAND:
5498. case TILDE:
5499. case ELLIPSIS:
5500. case SCOPE:
5501. case LITERAL__cdecl:
5502. case LITERAL___cdecl:
5503. case LITERAL__near:
5504. case LITERAL___near:
5505. case LITERAL__far:
5506. case LITERAL___far:
5507. case LITERAL___interrupt:
5508. case LITERAL_pascal:
5509. case LITERAL__pascal:
5510. case LITERAL___pascal:
5511. {
5512. parameter_list();
5513. break;
5514. }
5515. case RPAREN:
5516. {
5517. break;
5518. }
5519. default:
5520. {
5521. throw new NoViableAltException(LT(1), getFilename());
5522. }
5523. }
5524. }
5525. match(RPAREN);
5526. {
5527. _loop232:
5528. do {
5529. if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL_volatile)) && (_tokenSet_47.member(LA(2)))) {
5530. type_qualifier();
5531. }
5532. else {
5533. break _loop232;
5534. }
5535.
5536. } while (true);
5537. }
5538. {
5539. switch ( LA(1)) {
5540. case ASSIGNEQUAL:
5541. {
5542. match(ASSIGNEQUAL);
5543. match(OCTALINT);
5544. break;
5545. }
5546. case LITERAL_typedef:
5547. case LITERAL_enum:
5548. case ID:
5549. case LCURLY:
5550. case SEMICOLON:
5551. case LITERAL_inline:
5552. case LITERAL_extern:
5553. case LITERAL__inline:
5554. case LITERAL___inline:
5555. case LITERAL_virtual:
5556. case LITERAL_explicit:
5557. case LITERAL_friend:
5558. case LITERAL__stdcall:
5559. case LITERAL___stdcall:
5560. case LITERAL__declspec:
5561. case LITERAL___declspec:
5562. case LITERAL_typename:
5563. case LITERAL_auto:
5564. case LITERAL_register:
5565. case LITERAL_static:
5566. case LITERAL_mutable:
5567. case LITERAL_const:
5568. case LITERAL_const_cast:
5569. case LITERAL_volatile:
5570. case LITERAL_char:
5571. case LITERAL_wchar_t:
5572. case LITERAL_bool:
5573. case LITERAL_short:
5574. case LITERAL_int:
5575. case 44:
5576. case 45:
5577. case 46:
5578. case LITERAL_long:
5579. case LITERAL_signed:
5580. case LITERAL_unsigned:
5581. case LITERAL_float:
5582. case LITERAL_double:
5583. case LITERAL_void:
5584. case LITERAL_class:
5585. case LITERAL_struct:
5586. case LITERAL_union:
5587. case LITERAL_throw:
5588. case LITERAL_using:
5589. case SCOPE:
5590. {
5591. break;
5592. }
5593. default:
5594. {
5595. throw new NoViableAltException(LT(1), getFilename());
5596. }
5597. }
5598. }
5599. {
5600. switch ( LA(1)) {
5601. case LITERAL_throw:
5602. {
5603. exception_specification();
5604. break;
5605. }
5606. case LITERAL_typedef:
5607. case LITERAL_enum:
5608. case ID:
5609. case LCURLY:
5610. case SEMICOLON:
5611. case LITERAL_inline:
5612. case LITERAL_extern:
5613. case LITERAL__inline:
5614. case LITERAL___inline:
5615. case LITERAL_virtual:
5616. case LITERAL_explicit:
5617. case LITERAL_friend:
5618. case LITERAL__stdcall:
5619. case LITERAL___stdcall:
5620. case LITERAL__declspec:
5621. case LITERAL___declspec:
5622. case LITERAL_typename:
5623. case LITERAL_auto:
5624. case LITERAL_register:
5625. case LITERAL_static:
5626. case LITERAL_mutable:
5627. case LITERAL_const:
5628. case LITERAL_const_cast:
5629. case LITERAL_volatile:
5630. case LITERAL_char:
5631. case LITERAL_wchar_t:
5632. case LITERAL_bool:
5633. case LITERAL_short:
5634. case LITERAL_int:
5635. case 44:
5636. case 45:
5637. case 46:
5638. case LITERAL_long:
5639. case LITERAL_signed:
5640. case LITERAL_unsigned:
5641. case LITERAL_float:
5642. case LITERAL_double:
5643. case LITERAL_void:
5644. case LITERAL_class:
5645. case LITERAL_struct:
5646. case LITERAL_union:
5647. case LITERAL_using:
5648. case SCOPE:
5649. {
5650. break;
5651. }
5652. default:
5653. {
5654. throw new NoViableAltException(LT(1), getFilename());
5655. }
5656. }
5657. }
5658. }
5659.
5660. public final void ctor_head() throws RecognitionException, TokenStreamException {
5661.
5662.
5663. ctor_decl_spec();
5664. ctor_declarator();
5665. }
5666.
5667. public final void ctor_body() throws RecognitionException, TokenStreamException {
5668.
5669.
5670. {
5671. switch ( LA(1)) {
5672. case COLON:
5673. {
5674. ctor_initializer();
5675. break;
5676. }
5677. case LCURLY:
5678. {
5679. break;
5680. }
5681. default:
5682. {
5683. throw new NoViableAltException(LT(1), getFilename());
5684. }
5685. }
5686. }
5687. compound_statement();
5688. }
5689.
5690. public final String qualified_ctor_id() throws RecognitionException, TokenStreamException {
5691. String q="";
5692.
5693. Token id = null;
5694.
5695. String so="";
5696. String qitem="";
5697.
5698.
5699. so=scope_override();
5700. if ( inputState.guessing==0 ) {
5701. qitem=so;
5702. }
5703. id = LT(1);
5704. match(ID);
5705. if ( inputState.guessing==0 ) {
5706. qitem=qitem+id.getText();
5707. q = qitem;
5708. }
5709. return q;
5710. }
5711.
5712. public final void ctor_initializer() throws RecognitionException, TokenStreamException {
5713.
5714.
5715. match(COLON);
5716. superclass_init();
5717. {
5718. _loop249:
5719. do {
5720. if ((LA(1)==COMMA)) {
5721. match(COMMA);
5722. superclass_init();
5723. }
5724. else {
5725. break _loop249;
5726. }
5727.
5728. } while (true);
5729. }
5730. }
5731.
5732. public final void superclass_init() throws RecognitionException, TokenStreamException {
5733.
5734. String q="";
5735.
5736. q=qualified_id();
5737. match(LPAREN);
5738. {
5739. switch ( LA(1)) {
5740. case ID:
5741. case StringLiteral:
5742. case LITERAL__declspec:
5743. case LITERAL___declspec:
5744. case LPAREN:
5745. case LITERAL_const_cast:
5746. case LITERAL_char:
5747. case LITERAL_wchar_t:
5748. case LITERAL_bool:
5749. case LITERAL_short:
5750. case LITERAL_int:
5751. case 44:
5752. case 45:
5753. case 46:
5754. case LITERAL_long:
5755. case LITERAL_signed:
5756. case LITERAL_unsigned:
5757. case LITERAL_float:
5758. case LITERAL_double:
5759. case LITERAL_void:
5760. case OPERATOR:
5761. case LITERAL_this:
5762. case LITERAL_true:
5763. case LITERAL_false:
5764. case OCTALINT:
5765. case STAR:
5766. case AMPERSAND:
5767. case TILDE:
5768. case PLUS:
5769. case MINUS:
5770. case PLUSPLUS:
5771. case MINUSMINUS:
5772. case LITERAL_sizeof:
5773. case SCOPE:
5774. case LITERAL_dynamic_cast:
5775. case LITERAL_static_cast:
5776. case LITERAL_reinterpret_cast:
5777. case NOT:
5778. case LITERAL_new:
5779. case LITERAL_delete:
5780. case DECIMALINT:
5781. case HEXADECIMALINT:
5782. case CharLiteral:
5783. case FLOATONE:
5784. case FLOATTWO:
5785. {
5786. expression_list();
5787. break;
5788. }
5789. case RPAREN:
5790. {
5791. break;
5792. }
5793. default:
5794. {
5795. throw new NoViableAltException(LT(1), getFilename());
5796. }
5797. }
5798. }
5799. match(RPAREN);
5800. }
5801.
5802. public final void dtor_decl_spec() throws RecognitionException, TokenStreamException {
5803.
5804. List declSpecs = new ArrayList();
5805.
5806. {
5807. _loop256:
5808. do {
5809. switch ( LA(1)) {
5810. case LITERAL_inline:
5811. case LITERAL__inline:
5812. case LITERAL___inline:
5813. {
5814. {
5815. switch ( LA(1)) {
5816. case LITERAL_inline:
5817. {
5818. match(LITERAL_inline);
5819. break;
5820. }
5821. case LITERAL__inline:
5822. {
5823. match(LITERAL__inline);
5824. break;
5825. }
5826. case LITERAL___inline:
5827. {
5828. match(LITERAL___inline);
5829. break;
5830. }
5831. default:
5832. {
5833. throw new NoViableAltException(LT(1), getFilename());
5834. }
5835. }
5836. }
5837. if ( inputState.guessing==0 ) {
5838. declSpecs.add("inline");
5839. }
5840. break;
5841. }
5842. case LITERAL_virtual:
5843. {
5844. match(LITERAL_virtual);
5845. if ( inputState.guessing==0 ) {
5846. declSpecs.add("virtual");
5847. }
5848. break;
5849. }
5850. default:
5851. {
5852. break _loop256;
5853. }
5854. }
5855. } while (true);
5856. }
5857. if ( inputState.guessing==0 ) {
5858. m.declarationSpecifiers(declSpecs);
5859. }
5860. }
5861.
5862. public final void dtor_declarator() throws RecognitionException, TokenStreamException {
5863.
5864. Token id = null;
5865. String s="";
5866.
5867. s=scope_override();
5868. match(TILDE);
5869. id = LT(1);
5870. match(ID);
5871. if ( inputState.guessing==0 ) {
5872. m.dtorDeclarator(s+"~"+id.getText());
5873. }
5874. match(LPAREN);
5875. match(RPAREN);
5876. {
5877. switch ( LA(1)) {
5878. case LITERAL_throw:
5879. {
5880. exception_specification();
5881. break;
5882. }
5883. case LCURLY:
5884. case SEMICOLON:
5885. {
5886. break;
5887. }
5888. default:
5889. {
5890. throw new NoViableAltException(LT(1), getFilename());
5891. }
5892. }
5893. }
5894. }
5895.
5896. public final void parameter_declaration_list() throws RecognitionException, TokenStreamException {
...5897.
5898.
5899. {
5900. parameter_declaration();
5901. {
5902. _loop265:
5903. do {
5904. if ((LA(1)==COMMA)) {
5905. match(COMMA);
5906. parameter_declaration();
5907. }
5908. else {
5909. break _loop265;
5910. }
5911.
5912. } while (true);
5913. }
5914. }
5915. }
5916.
5917. public final void parameter_declaration() throws RecognitionException, TokenStreamException {
5918.
5919. java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone(); auxBitSet.or(CPPvariabl...5920.
5921. if ( inputState.guessing==0 ) {
5922. m.beginParameterDeclaration();
5923. }
5924. {
5925. if (((_tokenSet_11.member(LA(1))) && (_tokenSet_48.member(LA(2))))&&(!((LA(1)==SCOPE) && (LA(2)==S...5926. declaration_specifiers();
5927. {
5928. boolean synPredMatched270 = false;
5929. if (((_tokenSet_45.member(LA(1))) && (_tokenSet_49.member(LA(2))))) {
5930. int _m270 = mark();
5931. synPredMatched270 = true;
5932. inputState.guessing++;
5933. try {
5934. {
5935. declarator();
5936. }
5937. }
5938. catch (RecognitionException pe) {
5939. synPredMatched270 = false;
5940. }
5941. rewind(_m270);
5942. inputState.guessing--;
5943. }
5944. if ( synPredMatched270 ) {
5945. declarator();
5946. }
5947. else if ((_tokenSet_50.member(LA(1))) && (_tokenSet_51.member(LA(2)))) {
5948. abstract_declarator();
5949. }
5950. else {
5951. throw new NoViableAltException(LT(1), getFilename());
5952. }
5953.
5954. }
5955. }
5956. else {
5957. boolean synPredMatched272 = false;
5958. if (((_tokenSet_45.member(LA(1))) && (_tokenSet_49.member(LA(2))))) {
5959. int _m272 = mark();
5960. synPredMatched272 = true;
5961. inputState.guessing++;
5962. try {
5963. {
5964. declarator();
5965. }
5966. }
5967. catch (RecognitionException pe) {
5968. synPredMatched272 = false;
5969. }
5970. rewind(_m272);
5971. inputState.guessing--;
5972. }
5973. if ( synPredMatched272 ) {
5974. declarator();
5975. }
5976. else if ((LA(1)==ELLIPSIS)) {
5977. match(ELLIPSIS);
5978. }
5979. else {
5980. throw new NoViableAltException(LT(1), getFilename());
5981. }
5982. }
5983. }
5984. {
5985. switch ( LA(1)) {
5986. case ASSIGNEQUAL:
5987. {
5988. match(ASSIGNEQUAL);
5989. remainder_expression();
5990. break;
5991. }
5992. case GREATERTHAN:
5993. case COMMA:
5994. case RPAREN:
5995. case ELLIPSIS:
5996. {
5997. break;
5998. }
5999. default:
6000. {
6001. throw new NoViableAltException(LT(1), getFilename());
6002. }
6003. }
6004. }
6005. if ( inputState.guessing==0 ) {
6006. m.endParameterDeclaration();
6007. }
6008. }
6009.
6010. public final void abstract_declarator() throws RecognitionException, TokenStreamException {
6011.
6012.
6013. switch ( LA(1)) {
6014. case ID:
6015. case LITERAL__stdcall:
6016. case LITERAL___stdcall:
6017. case STAR:
6018. case AMPERSAND:
6019. case SCOPE:
6020. case LITERAL__cdecl:
6021. case LITERAL___cdecl:
6022. case LITERAL__near:
6023. case LITERAL___near:
6024. case LITERAL__far:
6025. case LITERAL___far:
6026. case LITERAL___interrupt:
6027. case LITERAL_pascal:
6028. case LITERAL__pascal:
6029. case LITERAL___pascal:
6030. {
6031. ptr_operator();
6032. abstract_declarator();
6033. break;
6034. }
6035. case LPAREN:
6036. {
6037. match(LPAREN);
6038. abstract_declarator();
6039. match(RPAREN);
6040. {
6041. int _cnt277=0;
6042. _loop277:
6043. do {
6044. if ((LA(1)==LPAREN||LA(1)==LSQUARE)) {
6045. abstract_declarator_suffix();
6046. }
6047. else {
6048. if ( _cnt277>=1 ) { break _loop277; } else {throw new NoViableAltException(LT(1), getFilename()...6049. }
6050.
6051. _cnt277++;
6052. } while (true);
6053. }
6054. break;
6055. }
6056. case LSQUARE:
6057. {
6058. {
6059. int _cnt280=0;
6060. _loop280:
6061. do {
6062. if ((LA(1)==LSQUARE)) {
6063. match(LSQUARE);
6064. {
6065. switch ( LA(1)) {
6066. case ID:
6067. case StringLiteral:
6068. case LITERAL__declspec:
6069. case LITERAL___declspec:
6070. case LPAREN:
6071. case LITERAL_const_cast:
6072. case LITERAL_char:
6073. case LITERAL_wchar_t:
6074. case LITERAL_bool:
6075. case LITERAL_short:
6076. case LITERAL_int:
6077. case 44:
6078. case 45:
6079. case 46:
6080. case LITERAL_long:
6081. case LITERAL_signed:
6082. case LITERAL_unsigned:
6083. case LITERAL_float:
6084. case LITERAL_double:
6085. case LITERAL_void:
6086. case OPERATOR:
6087. case LITERAL_this:
6088. case LITERAL_true:
6089. case LITERAL_false:
6090. case OCTALINT:
6091. case STAR:
6092. case AMPERSAND:
6093. case TILDE:
6094. case PLUS:
6095. case MINUS:
6096. case PLUSPLUS:
6097. case MINUSMINUS:
6098. case LITERAL_sizeof:
6099. case SCOPE:
6100. case LITERAL_dynamic_cast:
6101. case LITERAL_static_cast:
6102. case LITERAL_reinterpret_cast:
6103. case NOT:
6104. case LITERAL_new:
6105. case LITERAL_delete:
6106. case DECIMALINT:
6107. case HEXADECIMALINT:
6108. case CharLiteral:
6109. case FLOATONE:
6110. case FLOATTWO:
6111. {
6112. constant_expression();
6113. break;
6114. }
6115. case RSQUARE:
6116. {
6117. break;
6118. }
6119. default:
6120. {
6121. throw new NoViableAltException(LT(1), getFilename());
6122. }
6123. }
6124. }
6125. match(RSQUARE);
6126. }
6127. else {
6128. if ( _cnt280>=1 ) { break _loop280; } else {throw new NoViableAltException(LT(1), getFilename()...6129. }
6130.
6131. _cnt280++;
6132. } while (true);
6133. }
6134. break;
6135. }
6136. case GREATERTHAN:
6137. case ASSIGNEQUAL:
6138. case COMMA:
6139. case RPAREN:
6140. case ELLIPSIS:
6141. {
6142. break;
6143. }
6144. default:
6145. {
6146. throw new NoViableAltException(LT(1), getFilename());
6147. }
6148. }
6149. }
6150.
6151. public final void type_name() throws RecognitionException, TokenStreamException {
6152.
6153.
6154. declaration_specifiers();
6155. abstract_declarator();
6156. }
6157.
6158. public final void abstract_declarator_suffix() throws RecognitionException, TokenStreamException {
...6159.
6160.
6161. switch ( LA(1)) {
6162. case LSQUARE:
6163. {
6164. match(LSQUARE);
6165. {
6166. switch ( LA(1)) {
6167. case ID:
6168. case StringLiteral:
6169. case LITERAL__declspec:
6170. case LITERAL___declspec:
6171. case LPAREN:
6172. case LITERAL_const_cast:
6173. case LITERAL_char:
6174. case LITERAL_wchar_t:
6175. case LITERAL_bool:
6176. case LITERAL_short:
6177. case LITERAL_int:
6178. case 44:
6179. case 45:
6180. case 46:
6181. case LITERAL_long:
6182. case LITERAL_signed:
6183. case LITERAL_unsigned:
6184. case LITERAL_float:
6185. case LITERAL_double:
6186. case LITERAL_void:
6187. case OPERATOR:
6188. case LITERAL_this:
6189. case LITERAL_true:
6190. case LITERAL_false:
6191. case OCTALINT:
6192. case STAR:
6193. case AMPERSAND:
6194. case TILDE:
6195. case PLUS:
6196. case MINUS:
6197. case PLUSPLUS:
6198. case MINUSMINUS:
6199. case LITERAL_sizeof:
6200. case SCOPE:
6201. case LITERAL_dynamic_cast:
6202. case LITERAL_static_cast:
6203. case LITERAL_reinterpret_cast:
6204. case NOT:
6205. case LITERAL_new:
6206. case LITERAL_delete:
6207. case DECIMALINT:
6208. case HEXADECIMALINT:
6209. case CharLiteral:
6210. case FLOATONE:
6211. case FLOATTWO:
6212. {
6213. constant_expression();
6214. break;
6215. }
6216. case RSQUARE:
6217. {
6218. break;
6219. }
6220. default:
6221. {
6222. throw new NoViableAltException(LT(1), getFilename());
6223. }
6224. }
6225. }
6226. match(RSQUARE);
6227. break;
6228. }
6229. case LPAREN:
6230. {
6231. match(LPAREN);
6232. {
6233. switch ( LA(1)) {
6234. case LITERAL_typedef:
6235. case LITERAL_enum:
6236. case ID:
6237. case LITERAL_inline:
6238. case LITERAL_extern:
6239. case LITERAL__inline:
6240. case LITERAL___inline:
6241. case LITERAL_virtual:
6242. case LITERAL_explicit:
6243. case LITERAL_friend:
6244. case LITERAL__stdcall:
6245. case LITERAL___stdcall:
6246. case LITERAL__declspec:
6247. case LITERAL___declspec:
6248. case LPAREN:
6249. case LITERAL_typename:
6250. case LITERAL_auto:
6251. case LITERAL_register:
6252. case LITERAL_static:
6253. case LITERAL_mutable:
6254. case LITERAL_const:
6255. case LITERAL_const_cast:
6256. case LITERAL_volatile:
6257. case LITERAL_char:
6258. case LITERAL_wchar_t:
6259. case LITERAL_bool:
6260. case LITERAL_short:
6261. case LITERAL_int:
6262. case 44:
6263. case 45:
6264. case 46:
6265. case LITERAL_long:
6266. case LITERAL_signed:
6267. case LITERAL_unsigned:
6268. case LITERAL_float:
6269. case LITERAL_double:
6270. case LITERAL_void:
6271. case LITERAL_class:
6272. case LITERAL_struct:
6273. case LITERAL_union:
6274. case OPERATOR:
6275. case LITERAL_this:
6276. case LITERAL_true:
6277. case LITERAL_false:
6278. case STAR:
6279. case AMPERSAND:
6280. case TILDE:
6281. case ELLIPSIS:
6282. case SCOPE:
6283. case LITERAL__cdecl:
6284. case LITERAL___cdecl:
6285. case LITERAL__near:
6286. case LITERAL___near:
6287. case LITERAL__far:
6288. case LITERAL___far:
6289. case LITERAL___interrupt:
6290. case LITERAL_pascal:
6291. case LITERAL__pascal:
6292. case LITERAL___pascal:
6293. {
6294. parameter_list();
6295. break;
6296. }
6297. case RPAREN:
6298. {
6299. break;
6300. }
6301. default:
6302. {
6303. throw new NoViableAltException(LT(1), getFilename());
6304. }
6305. }
6306. }
6307. match(RPAREN);
6308. cv_qualifier_seq();
6309. {
6310. switch ( LA(1)) {
6311. case LITERAL_throw:
6312. {
6313. exception_specification();
6314. break;
6315. }
6316. case GREATERTHAN:
6317. case ASSIGNEQUAL:
6318. case COMMA:
6319. case LPAREN:
6320. case RPAREN:
6321. case LSQUARE:
6322. case ELLIPSIS:
6323. {
6324. break;
6325. }
6326. default:
6327. {
6328. throw new NoViableAltException(LT(1), getFilename());
6329. }
6330. }
6331. }
6332. break;
6333. }
6334. default:
6335. {
6336. throw new NoViableAltException(LT(1), getFilename());
6337. }
6338. }
6339. }
6340.
6341. public final void template_parameter() throws RecognitionException, TokenStreamException {
6342.
6343. Token id = null;
6344.
6345. {
6346. if ((LA(1)==LITERAL_typename||LA(1)==LITERAL_class) && (_tokenSet_52.member(LA(2)))) {
6347. {
6348. switch ( LA(1)) {
6349. case LITERAL_class:
6350. {
6351. match(LITERAL_class);
6352. break;
6353. }
6354. case LITERAL_typename:
6355. {
6356. match(LITERAL_typename);
6357. break;
6358. }
6359. default:
6360. {
6361. throw new NoViableAltException(LT(1), getFilename());
6362. }
6363. }
6364. }
6365. {
6366. switch ( LA(1)) {
6367. case ID:
6368. {
6369. id = LT(1);
6370. match(ID);
6371. {
6372. switch ( LA(1)) {
6373. case ASSIGNEQUAL:
6374. {
6375. match(ASSIGNEQUAL);
6376. assigned_type_name();
6377. break;
6378. }
6379. case GREATERTHAN:
6380. case COMMA:
6381. {
6382. break;
6383. }
6384. default:
6385. {
6386. throw new NoViableAltException(LT(1), getFilename());
6387. }
6388. }
6389. }
6390. break;
6391. }
6392. case GREATERTHAN:
6393. case COMMA:
6394. {
6395. break;
6396. }
6397. default:
6398. {
6399. throw new NoViableAltException(LT(1), getFilename());
6400. }
6401. }
6402. }
6403. if ( inputState.guessing==0 ) {
6404. if(!symbols.containsKey(id.getText()))
6405. symbols.put(id.getText(),CPPvariables.OT_TYPE_DEF);
6406.
6407. }
6408. }
6409. else if ((_tokenSet_53.member(LA(1))) && (_tokenSet_10.member(LA(2)))) {
6410. parameter_declaration();
6411. }
6412. else {
6413. throw new NoViableAltException(LT(1), getFilename());
6414. }
6415.
6416. }
6417. }
6418.
6419. public final void assigned_type_name() throws RecognitionException, TokenStreamException {
6420.
6421. String s="";
6422.
6423. {
6424. if ((LA(1)==ID||LA(1)==SCOPE) && (_tokenSet_54.member(LA(2)))) {
6425. s=qualified_type();
6426. abstract_declarator();
6427. }
6428. else if ((_tokenSet_55.member(LA(1))) && (_tokenSet_56.member(LA(2)))) {
6429. simple_type_specifier();
6430. abstract_declarator();
6431. }
6432. else {
6433. throw new NoViableAltException(LT(1), getFilename());
6434. }
6435.
6436. }
6437. }
6438.
6439. public final void template_id() throws RecognitionException, TokenStreamException {
6440.
6441.
6442. match(ID);
6443. match(LESSTHAN);
6444. template_argument_list();
6445. match(GREATERTHAN);
6446. }
6447.
6448. public final void template_argument() throws RecognitionException, TokenStreamException {
6449.
6450. java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone(); auxBitSet.or(CPPvariabl...6451.
6452. if (((_tokenSet_11.member(LA(1))) && (_tokenSet_57.member(LA(2))))&&(( !(LA(1)==SCOPE||LA(1)==ID) ...6453. type_name();
6454. }
6455. else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_58.member(LA(2)))) {
6456. shift_expression();
6457. }
6458. else {
6459. throw new NoViableAltException(LT(1), getFilename());
6460. }
6461.
6462. }
6463.
6464. public final void shift_expression() throws RecognitionException, TokenStreamException {
6465.
6466.
6467. additive_expression();
6468. {
6469. _loop385:
6470. do {
6471. if ((LA(1)==SHIFTLEFT||LA(1)==SHIFTRIGHT)) {
6472. {
6473. switch ( LA(1)) {
6474. case SHIFTLEFT:
6475. {
6476. match(SHIFTLEFT);
6477. break;
6478. }
6479. case SHIFTRIGHT:
6480. {
6481. match(SHIFTRIGHT);
6482. break;
6483. }
6484. default:
6485. {
6486. throw new NoViableAltException(LT(1), getFilename());
6487. }
6488. }
6489. }
6490. additive_expression();
6491. }
6492. else {
6493. break _loop385;
6494. }
6495.
6496. } while (true);
6497. }
6498. }
6499.
6500. public final void statement_list() throws RecognitionException, TokenStreamException {
6501.
6502.
6503. {
6504. int _cnt308=0;
6505. _loop308:
6506. do {
6507. if ((_tokenSet_59.member(LA(1)))) {
6508. statement();
6509. }
6510. else {
6511. if ( _cnt308>=1 ) { break _loop308; } else {throw new NoViableAltException(LT(1), getFilename())...6512. }
6513.
6514. _cnt308++;
6515. } while (true);
6516. }
6517. }
6518.
6519. public final void statement() throws RecognitionException, TokenStreamException {
6520.
6521.
6522. {
6523. switch ( LA(1)) {
6524. case LITERAL_case:
6525. {
6526. case_statement();
6527. break;
6528. }
6529. case LITERAL_default:
6530. {
6531. default_statement();
6532. break;
6533. }
6534. case LCURLY:
6535. {
6536. compound_statement();
6537. break;
6538. }
6539. case LITERAL_if:
6540. case LITERAL_switch:
6541. {
6542. selection_statement();
6543. break;
6544. }
6545. case LITERAL_while:
6546. case LITERAL_do:
6547. case LITERAL_for:
6548. {
6549. iteration_statement();
6550. break;
6551. }
6552. case LITERAL_goto:
6553. case LITERAL_continue:
6554. case LITERAL_break:
6555. case LITERAL_return:
6556. {
6557. jump_statement();
6558. break;
6559. }
6560. case SEMICOLON:
6561. {
6562. match(SEMICOLON);
6563. break;
6564. }
6565. case LITERAL_try:
6566. {
6567. try_block();
6568. break;
6569. }
6570. case LITERAL_throw:
6571. {
6572. throw_statement();
6573. break;
6574. }
6575. case LITERAL__asm:
6576. case LITERAL___asm:
6577. {
6578. asm_block();
6579. break;
6580. }
6581. default:
6582. boolean synPredMatched312 = false;
6583. if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
6584. int _m312 = mark();
6585. synPredMatched312 = true;
6586. inputState.guessing++;
6587. try {
6588. {
6589. declaration();
6590. }
6591. }
6592. catch (RecognitionException pe) {
6593. synPredMatched312 = false;
6594. }
6595. rewind(_m312);
6596. inputState.guessing--;
6597. }
6598. if ( synPredMatched312 ) {
6599. declaration();
6600. }
6601. else if ((LA(1)==ID) && (LA(2)==COLON)) {
6602. labeled_statement();
6603. }
6604. else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_60.member(LA(2)))) {
6605. expression();
6606. match(SEMICOLON);
6607. }
6608. else {
6609. throw new NoViableAltException(LT(1), getFilename());
6610. }
6611. }
6612. }
6613. }
6614.
6615. public final void labeled_statement() throws RecognitionException, TokenStreamException {
6616.
6617.
6618. match(ID);
6619. match(COLON);
6620. statement();
6621. }
6622.
6623. public final void case_statement() throws RecognitionException, TokenStreamException {
6624.
6625.
6626. match(LITERAL_case);
6627. constant_expression();
6628. match(COLON);
6629. statement();
6630. }
6631.
6632. public final void default_statement() throws RecognitionException, TokenStreamException {
6633.
6634.
6635. match(LITERAL_default);
6636. match(COLON);
6637. statement();
6638. }
6639.
6640. public final void expression() throws RecognitionException, TokenStreamException {
6641.
6642.
6643. assignment_expression();
6644. {
6645. _loop347:
6646. do {
6647. if ((LA(1)==COMMA)) {
6648. match(COMMA);
6649. assignment_expression();
6650. }
6651. else {
6652. break _loop347;
6653. }
6654.
6655. } while (true);
6656. }
6657. }
6658.
6659. public final void selection_statement() throws RecognitionException, TokenStreamException {
6660.
6661.
6662. switch ( LA(1)) {
6663. case LITERAL_if:
6664. {
6665. match(LITERAL_if);
6666. match(LPAREN);
6667. expression();
6668. match(RPAREN);
6669. statement();
6670. {
6671. if ((LA(1)==LITERAL_else) && (_tokenSet_59.member(LA(2)))) {
6672. match(LITERAL_else);
6673. statement();
6674. }
6675. else if ((_tokenSet_61.member(LA(1))) && (_tokenSet_62.member(LA(2)))) {
6676. }
6677. else {
6678. throw new NoViableAltException(LT(1), getFilename());
6679. }
6680.
6681. }
6682. break;
6683. }
6684. case LITERAL_switch:
6685. {
6686. match(LITERAL_switch);
6687. match(LPAREN);
6688. expression();
6689. match(RPAREN);
6690. statement();
6691. break;
6692. }
6693. default:
6694. {
6695. throw new NoViableAltException(LT(1), getFilename());
6696. }
6697. }
6698. }
6699.
6700. public final void iteration_statement() throws RecognitionException, TokenStreamException {
6701.
6702.
6703. switch ( LA(1)) {
6704. case LITERAL_while:
6705. {
6706. match(LITERAL_while);
6707. match(LPAREN);
6708. expression();
6709. match(RPAREN);
6710. statement();
6711. break;
6712. }
6713. case LITERAL_do:
6714. {
6715. match(LITERAL_do);
6716. statement();
6717. match(LITERAL_while);
6718. match(LPAREN);
6719. expression();
6720. match(RPAREN);
6721. match(SEMICOLON);
6722. break;
6723. }
6724. case LITERAL_for:
6725. {
6726. match(LITERAL_for);
6727. match(LPAREN);
6728. {
6729. boolean synPredMatched323 = false;
6730. if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
6731. int _m323 = mark();
6732. synPredMatched323 = true;
6733. inputState.guessing++;
6734. try {
6735. {
6736. declaration();
6737. }
6738. }
6739. catch (RecognitionException pe) {
6740. synPredMatched323 = false;
6741. }
6742. rewind(_m323);
6743. inputState.guessing--;
6744. }
6745. if ( synPredMatched323 ) {
6746. declaration();
6747. }
6748. else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_60.member(LA(2)))) {
6749. expression();
6750. match(SEMICOLON);
6751. }
6752. else if ((LA(1)==SEMICOLON)) {
6753. match(SEMICOLON);
6754. }
6755. else {
6756. throw new NoViableAltException(LT(1), getFilename());
6757. }
6758.
6759. }
6760. {
6761. switch ( LA(1)) {
6762. case ID:
6763. case StringLiteral:
6764. case LITERAL__declspec:
6765. case LITERAL___declspec:
6766. case LPAREN:
6767. case LITERAL_const_cast:
6768. case LITERAL_char:
6769. case LITERAL_wchar_t:
6770. case LITERAL_bool:
6771. case LITERAL_short:
6772. case LITERAL_int:
6773. case 44:
6774. case 45:
6775. case 46:
6776. case LITERAL_long:
6777. case LITERAL_signed:
6778. case LITERAL_unsigned:
6779. case LITERAL_float:
6780. case LITERAL_double:
6781. case LITERAL_void:
6782. case OPERATOR:
6783. case LITERAL_this:
6784. case LITERAL_true:
6785. case LITERAL_false:
6786. case OCTALINT:
6787. case STAR:
6788. case AMPERSAND:
6789. case TILDE:
6790. case PLUS:
6791. case MINUS:
6792. case PLUSPLUS:
6793. case MINUSMINUS:
6794. case LITERAL_sizeof:
6795. case SCOPE:
6796. case LITERAL_dynamic_cast:
6797. case LITERAL_static_cast:
6798. case LITERAL_reinterpret_cast:
6799. case NOT:
6800. case LITERAL_new:
6801. case LITERAL_delete:
6802. case DECIMALINT:
6803. case HEXADECIMALINT:
6804. case CharLiteral:
6805. case FLOATONE:
6806. case FLOATTWO:
6807. {
6808. expression();
6809. break;
6810. }
6811. case SEMICOLON:
6812. {
6813. break;
6814. }
6815. default:
6816. {
6817. throw new NoViableAltException(LT(1), getFilename());
6818. }
6819. }
6820. }
6821. match(SEMICOLON);
6822. {
6823. switch ( LA(1)) {
6824. case ID:
6825. case StringLiteral:
6826. case LITERAL__declspec:
6827. case LITERAL___declspec:
6828. case LPAREN:
6829. case LITERAL_const_cast:
6830. case LITERAL_char:
6831. case LITERAL_wchar_t:
6832. case LITERAL_bool:
6833. case LITERAL_short:
6834. case LITERAL_int:
6835. case 44:
6836. case 45:
6837. case 46:
6838. case LITERAL_long:
6839. case LITERAL_signed:
6840. case LITERAL_unsigned:
6841. case LITERAL_float:
6842. case LITERAL_double:
6843. case LITERAL_void:
6844. case OPERATOR:
6845. case LITERAL_this:
6846. case LITERAL_true:
6847. case LITERAL_false:
6848. case OCTALINT:
6849. case STAR:
6850. case AMPERSAND:
6851. case TILDE:
6852. case PLUS:
6853. case MINUS:
6854. case PLUSPLUS:
6855. case MINUSMINUS:
6856. case LITERAL_sizeof:
6857. case SCOPE:
6858. case LITERAL_dynamic_cast:
6859. case LITERAL_static_cast:
6860. case LITERAL_reinterpret_cast:
6861. case NOT:
6862. case LITERAL_new:
6863. case LITERAL_delete:
6864. case DECIMALINT:
6865. case HEXADECIMALINT:
6866. case CharLiteral:
6867. case FLOATONE:
6868. case FLOATTWO:
6869. {
6870. expression();
6871. break;
6872. }
6873. case RPAREN:
6874. {
6875. break;
6876. }
6877. default:
6878. {
6879. throw new NoViableAltException(LT(1), getFilename());
6880. }
6881. }
6882. }
6883. match(RPAREN);
6884. statement();
6885. break;
6886. }
6887. default:
6888. {
6889. throw new NoViableAltException(LT(1), getFilename());
6890. }
6891. }
6892. }
6893.
6894. public final void jump_statement() throws RecognitionException, TokenStreamException {
6895.
6896.
6897. {
6898. switch ( LA(1)) {
6899. case LITERAL_goto:
6900. {
6901. match(LITERAL_goto);
6902. match(ID);
6903. match(SEMICOLON);
6904. break;
6905. }
6906. case LITERAL_continue:
6907. {
6908. match(LITERAL_continue);
6909. match(SEMICOLON);
6910. break;
6911. }
6912. case LITERAL_break:
6913. {
6914. match(LITERAL_break);
6915. match(SEMICOLON);
6916. break;
6917. }
6918. case LITERAL_return:
6919. {
6920. match(LITERAL_return);
6921. {
6922. boolean synPredMatched330 = false;
6923. if (((LA(1)==LPAREN) && (LA(2)==ID))) {
6924. int _m330 = mark();
6925. synPredMatched330 = true;
6926. inputState.guessing++;
6927. try {
6928. {
6929. match(LPAREN);
6930. if (!((qualifiedItemIsOneOf(CPPvariables.QI_TYPE,0) )))
6931. throw new SemanticException("(qualifiedItemIsOneOf(CPPvariables.QI_TYPE,0) )");
6932. match(ID);
6933. match(RPAREN);
6934. }
6935. }
6936. catch (RecognitionException pe) {
6937. synPredMatched330 = false;
6938. }
6939. rewind(_m330);
6940. inputState.guessing--;
6941. }
6942. if ( synPredMatched330 ) {
6943. match(LPAREN);
6944. match(ID);
6945. match(RPAREN);
6946. {
6947. switch ( LA(1)) {
6948. case ID:
6949. case StringLiteral:
6950. case LITERAL__declspec:
6951. case LITERAL___declspec:
6952. case LPAREN:
6953. case LITERAL_const_cast:
6954. case LITERAL_char:
6955. case LITERAL_wchar_t:
6956. case LITERAL_bool:
6957. case LITERAL_short:
6958. case LITERAL_int:
6959. case 44:
6960. case 45:
6961. case 46:
6962. case LITERAL_long:
6963. case LITERAL_signed:
6964. case LITERAL_unsigned:
6965. case LITERAL_float:
6966. case LITERAL_double:
6967. case LITERAL_void:
6968. case OPERATOR:
6969. case LITERAL_this:
6970. case LITERAL_true:
6971. case LITERAL_false:
6972. case OCTALINT:
6973. case STAR:
6974. case AMPERSAND:
6975. case TILDE:
6976. case PLUS:
6977. case MINUS:
6978. case PLUSPLUS:
6979. case MINUSMINUS:
6980. case LITERAL_sizeof:
6981. case SCOPE:
6982. case LITERAL_dynamic_cast:
6983. case LITERAL_static_cast:
6984. case LITERAL_reinterpret_cast:
6985. case NOT:
6986. case LITERAL_new:
6987. case LITERAL_delete:
6988. case DECIMALINT:
6989. case HEXADECIMALINT:
6990. case CharLiteral:
6991. case FLOATONE:
6992. case FLOATTWO:
6993. {
6994. expression();
6995. break;
6996. }
6997. case SEMICOLON:
6998. {
6999. break;
7000. }
7001. default:
7002. {
7003. throw new NoViableAltException(LT(1), getFilename());
7004. }
7005. }
7006. }
7007. }
7008. else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_60.member(LA(2)))) {
7009. expression();
7010. }
7011. else if ((LA(1)==SEMICOLON)) {
7012. }
7013. else {
7014. throw new NoViableAltException(LT(1), getFilename());
7015. }
7016.
7017. }
7018. match(SEMICOLON);
7019. break;
7020. }
7021. default:
7022. {
7023. throw new NoViableAltException(LT(1), getFilename());
7024. }
7025. }
7026. }
7027. }
7028.
7029. public final void try_block() throws RecognitionException, TokenStreamException {
7030.
7031.
7032. match(LITERAL_try);
7033. compound_statement();
7034. {
7035. _loop334:
7036. do {
7037. if ((LA(1)==LITERAL_catch)) {
7038. handler();
7039. }
7040. else {
7041. break _loop334;
7042. }
7043.
7044. } while (true);
7045. }
7046. }
7047.
7048. public final void throw_statement() throws RecognitionException, TokenStreamException {
7049.
7050.
7051. match(LITERAL_throw);
7052. {
7053. switch ( LA(1)) {
7054. case ID:
7055. case StringLiteral:
7056. case LITERAL__declspec:
7057. case LITERAL___declspec:
7058. case LPAREN:
7059. case LITERAL_const_cast:
7060. case LITERAL_char:
7061. case LITERAL_wchar_t:
7062. case LITERAL_bool:
7063. case LITERAL_short:
7064. case LITERAL_int:
7065. case 44:
7066. case 45:
7067. case 46:
7068. case LITERAL_long:
7069. case LITERAL_signed:
7070. case LITERAL_unsigned:
7071. case LITERAL_float:
7072. case LITERAL_double:
7073. case LITERAL_void:
7074. case OPERATOR:
7075. case LITERAL_this:
7076. case LITERAL_true:
7077. case LITERAL_false:
7078. case OCTALINT:
7079. case STAR:
7080. case AMPERSAND:
7081. case TILDE:
7082. case PLUS:
7083. case MINUS:
7084. case PLUSPLUS:
7085. case MINUSMINUS:
7086. case LITERAL_sizeof:
7087. case SCOPE:
7088. case LITERAL_dynamic_cast:
7089. case LITERAL_static_cast:
7090. case LITERAL_reinterpret_cast:
7091. case NOT:
7092. case LITERAL_new:
7093. case LITERAL_delete:
7094. case DECIMALINT:
7095. case HEXADECIMALINT:
7096. case CharLiteral:
7097. case FLOATONE:
7098. case FLOATTWO:
7099. {
7100. assignment_expression();
7101. break;
7102. }
7103. case SEMICOLON:
7104. {
7105. break;
7106. }
7107. default:
7108. {
7109. throw new NoViableAltException(LT(1), getFilename());
7110. }
7111. }
7112. }
7113. match(SEMICOLON);
7114. }
7115.
7116. public final void asm_block() throws RecognitionException, TokenStreamException {
7117.
7118.
7119. {
7120. switch ( LA(1)) {
7121. case LITERAL__asm:
7122. {
7123. match(LITERAL__asm);
7124. break;
7125. }
7126. case LITERAL___asm:
7127. {
7128. match(LITERAL___asm);
7129. break;
7130. }
7131. default:
7132. {
7133. throw new NoViableAltException(LT(1), getFilename());
7134. }
7135. }
7136. }
7137. match(LCURLY);
7138. {
7139. _loop344:
7140. do {
7141. if ((_tokenSet_63.member(LA(1)))) {
7142. matchNot(RCURLY);
7143. }
7144. else {
7145. break _loop344;
7146. }
7147.
7148. } while (true);
7149. }
7150. match(RCURLY);
7151. }
7152.
7153. public final void handler() throws RecognitionException, TokenStreamException {
7154.
7155.
7156. match(LITERAL_catch);
7157. match(LPAREN);
7158. exception_declaration();
7159. match(RPAREN);
7160. compound_statement();
7161. }
7162.
7163. public final void exception_declaration() throws RecognitionException, TokenStreamException {
7164.
7165.
7166. parameter_declaration_list();
7167. }
7168.
7169. public final void assignment_expression() throws RecognitionException, TokenStreamException {
7170.
7171.
7172. conditional_expression();
7173. {
7174. switch ( LA(1)) {
7175. case ASSIGNEQUAL:
7176. case TIMESEQUAL:
7177. case DIVIDEEQUAL:
7178. case MINUSEQUAL:
7179. case PLUSEQUAL:
7180. case MODEQUAL:
7181. case SHIFTLEFTEQUAL:
7182. case SHIFTRIGHTEQUAL:
7183. case BITWISEANDEQUAL:
7184. case BITWISEXOREQUAL:
7185. case BITWISEOREQUAL:
7186. {
7187. {
7188. switch ( LA(1)) {
7189. case ASSIGNEQUAL:
7190. {
7191. match(ASSIGNEQUAL);
7192. break;
7193. }
7194. case TIMESEQUAL:
7195. {
7196. match(TIMESEQUAL);
7197. break;
7198. }
7199. case DIVIDEEQUAL:
7200. {
7201. match(DIVIDEEQUAL);
7202. break;
7203. }
7204. case MINUSEQUAL:
7205. {
7206. match(MINUSEQUAL);
7207. break;
7208. }
7209. case PLUSEQUAL:
7210. {
7211. match(PLUSEQUAL);
7212. break;
7213. }
7214. case MODEQUAL:
7215. {
7216. match(MODEQUAL);
7217. break;
7218. }
7219. case SHIFTLEFTEQUAL:
7220. {
7221. match(SHIFTLEFTEQUAL);
7222. break;
7223. }
7224. case SHIFTRIGHTEQUAL:
7225. {
7226. match(SHIFTRIGHTEQUAL);
7227. break;
7228. }
7229. case BITWISEANDEQUAL:
7230. {
7231. match(BITWISEANDEQUAL);
7232. break;
7233. }
7234. case BITWISEXOREQUAL:
7235. {
7236. match(BITWISEXOREQUAL);
7237. break;
7238. }
7239. case BITWISEOREQUAL:
7240. {
7241. match(BITWISEOREQUAL);
7242. break;
7243. }
7244. default:
7245. {
7246. throw new NoViableAltException(LT(1), getFilename());
7247. }
7248. }
7249. }
7250. remainder_expression();
7251. break;
7252. }
7253. case GREATERTHAN:
7254. case SEMICOLON:
7255. case RCURLY:
7256. case COLON:
7257. case COMMA:
7258. case RPAREN:
7259. case RSQUARE:
7260. case ELLIPSIS:
7261. {
7262. break;
7263. }
7264. default:
7265. {
7266. throw new NoViableAltException(LT(1), getFilename());
7267. }
7268. }
7269. }
7270. }
7271.
7272. public final void conditional_expression() throws RecognitionException, TokenStreamException {
7273.
7274.
7275. logical_or_expression();
7276. {
7277. switch ( LA(1)) {
7278. case QUESTIONMARK:
7279. {
7280. match(QUESTIONMARK);
7281. expression();
7282. match(COLON);
7283. conditional_expression();
7284. break;
7285. }
7286. case GREATERTHAN:
7287. case SEMICOLON:
7288. case RCURLY:
7289. case ASSIGNEQUAL:
7290. case COLON:
7291. case COMMA:
7292. case RPAREN:
7293. case RSQUARE:
7294. case ELLIPSIS:
7295. case TIMESEQUAL:
7296. case DIVIDEEQUAL:
7297. case MINUSEQUAL:
7298. case PLUSEQUAL:
7299. case MODEQUAL:
7300. case SHIFTLEFTEQUAL:
7301. case SHIFTRIGHTEQUAL:
7302. case BITWISEANDEQUAL:
7303. case BITWISEXOREQUAL:
7304. case BITWISEOREQUAL:
7305. {
7306. break;
7307. }
7308. default:
7309. {
7310. throw new NoViableAltException(LT(1), getFilename());
7311. }
7312. }
7313. }
7314. }
7315.
7316. public final void logical_or_expression() throws RecognitionException, TokenStreamException {
7317.
7318.
7319. logical_and_expression();
7320. {
7321. _loop361:
7322. do {
7323. if ((LA(1)==OR)) {
7324. match(OR);
7325. logical_and_expression();
7326. }
7327. else {
7328. break _loop361;
7329. }
7330.
7331. } while (true);
7332. }
7333. }
7334.
7335. public final void logical_and_expression() throws RecognitionException, TokenStreamException {
7336.
7337.
7338. inclusive_or_expression();
7339. {
7340. _loop364:
7341. do {
7342. if ((LA(1)==AND)) {
7343. match(AND);
7344. inclusive_or_expression();
7345. }
7346. else {
7347. break _loop364;
7348. }
7349.
7350. } while (true);
7351. }
7352. }
7353.
7354. public final void inclusive_or_expression() throws RecognitionException, TokenStreamException {
7355.
7356.
7357. exclusive_or_expression();
7358. {
7359. _loop367:
7360. do {
7361. if ((LA(1)==BITWISEOR)) {
7362. match(BITWISEOR);
7363. exclusive_or_expression();
7364. }
7365. else {
7366. break _loop367;
7367. }
7368.
7369. } while (true);
7370. }
7371. }
7372.
7373. public final void exclusive_or_expression() throws RecognitionException, TokenStreamException {
7374.
7375.
7376. and_expression();
7377. {
7378. _loop370:
7379. do {
7380. if ((LA(1)==BITWISEXOR)) {
7381. match(BITWISEXOR);
7382. and_expression();
7383. }
7384. else {
7385. break _loop370;
7386. }
7387.
7388. } while (true);
7389. }
7390. }
7391.
7392. public final void and_expression() throws RecognitionException, TokenStreamException {
7393.
7394.
7395. equality_expression();
7396. {
7397. _loop373:
7398. do {
7399. if ((LA(1)==AMPERSAND)) {
7400. match(AMPERSAND);
7401. equality_expression();
7402. }
7403. else {
7404. break _loop373;
7405. }
7406.
7407. } while (true);
7408. }
7409. }
7410.
7411. public final void equality_expression() throws RecognitionException, TokenStreamException {
7412.
7413.
7414. relational_expression();
7415. {
7416. _loop377:
7417. do {
7418. if ((LA(1)==NOTEQUAL||LA(1)==EQUAL)) {
7419. {
7420. switch ( LA(1)) {
7421. case NOTEQUAL:
7422. {
7423. match(NOTEQUAL);
7424. break;
7425. }
7426. case EQUAL:
7427. {
7428. match(EQUAL);
7429. break;
7430. }
7431. default:
7432. {
7433. throw new NoViableAltException(LT(1), getFilename());
7434. }
7435. }
7436. }
7437. relational_expression();
7438. }
7439. else {
7440. break _loop377;
7441. }
7442.
7443. } while (true);
7444. }
7445. }
7446.
7447. public final void relational_expression() throws RecognitionException, TokenStreamException {
7448.
7449.
7450. shift_expression();
7451. {
7452. _loop381:
7453. do {
7454. if ((_tokenSet_64.member(LA(1))) && (_tokenSet_42.member(LA(2)))) {
7455. {
7456. switch ( LA(1)) {
7457. case LESSTHAN:
7458. {
7459. match(LESSTHAN);
7460. break;
7461. }
7462. case GREATERTHAN:
7463. {
7464. match(GREATERTHAN);
7465. break;
7466. }
7467. case LESSTHANOREQUALTO:
7468. {
7469. match(LESSTHANOREQUALTO);
7470. break;
7471. }
7472. case GREATERTHANOREQUALTO:
7473. {
7474. match(GREATERTHANOREQUALTO);
7475. break;
7476. }
7477. default:
7478. {
7479. throw new NoViableAltException(LT(1), getFilename());
7480. }
7481. }
7482. }
7483. shift_expression();
7484. }
7485. else {
7486. break _loop381;
7487. }
7488.
7489. } while (true);
7490. }
7491. }
7492.
7493. public final void additive_expression() throws RecognitionException, TokenStreamException {
7494.
7495.
7496. multiplicative_expression();
7497. {
7498. _loop389:
7499. do {
7500. if ((LA(1)==PLUS||LA(1)==MINUS)) {
7501. {
7502. switch ( LA(1)) {
7503. case PLUS:
7504. {
7505. match(PLUS);
7506. break;
7507. }
7508. case MINUS:
7509. {
7510. match(MINUS);
7511. break;
7512. }
7513. default:
7514. {
7515. throw new NoViableAltException(LT(1), getFilename());
7516. }
7517. }
7518. }
7519. multiplicative_expression();
7520. }
7521. else {
7522. break _loop389;
7523. }
7524.
7525. } while (true);
7526. }
7527. }
7528.
7529. public final void multiplicative_expression() throws RecognitionException, TokenStreamException {
7530.
7531.
7532. pm_expression();
7533. {
7534. _loop393:
7535. do {
7536. if ((_tokenSet_65.member(LA(1)))) {
7537. {
7538. switch ( LA(1)) {
7539. case STAR:
7540. {
7541. match(STAR);
7542. break;
7543. }
7544. case DIVIDE:
7545. {
7546. match(DIVIDE);
7547. break;
7548. }
7549. case MOD:
7550. {
7551. match(MOD);
7552. break;
7553. }
7554. default:
7555. {
7556. throw new NoViableAltException(LT(1), getFilename());
7557. }
7558. }
7559. }
7560. pm_expression();
7561. }
7562. else {
7563. break _loop393;
7564. }
7565.
7566. } while (true);
7567. }
7568. }
7569.
7570. public final void pm_expression() throws RecognitionException, TokenStreamException {
7571.
7572.
7573. cast_expression();
7574. {
7575. _loop397:
7576. do {
7577. if ((LA(1)==DOTMBR||LA(1)==POINTERTOMBR)) {
7578. {
7579. switch ( LA(1)) {
7580. case DOTMBR:
7581. {
7582. match(DOTMBR);
7583. break;
7584. }
7585. case POINTERTOMBR:
7586. {
7587. match(POINTERTOMBR);
7588. break;
7589. }
7590. default:
7591. {
7592. throw new NoViableAltException(LT(1), getFilename());
7593. }
7594. }
7595. }
7596. cast_expression();
7597. }
7598. else {
7599. break _loop397;
7600. }
7601.
7602. } while (true);
7603. }
7604. }
7605.
7606. public final void cast_expression() throws RecognitionException, TokenStreamException {
7607.
7608.
7609. boolean synPredMatched402 = false;
7610. if (((LA(1)==LPAREN) && (_tokenSet_66.member(LA(2))))) {
7611. int _m402 = mark();
7612. synPredMatched402 = true;
7613. inputState.guessing++;
7614. try {
7615. {
7616. match(LPAREN);
7617. {
7618. switch ( LA(1)) {
7619. case LITERAL_const:
7620. case LITERAL_const_cast:
7621. case LITERAL_volatile:
7622. {
7623. type_qualifier();
7624. break;
7625. }
7626. case ID:
7627. case LITERAL__declspec:
7628. case LITERAL___declspec:
7629. case LITERAL_char:
7630. case LITERAL_wchar_t:
7631. case LITERAL_bool:
7632. case LITERAL_short:
7633. case LITERAL_int:
7634. case 44:
7635. case 45:
7636. case 46:
7637. case LITERAL_long:
7638. case LITERAL_signed:
7639. case LITERAL_unsigned:
7640. case LITERAL_float:
7641. case LITERAL_double:
7642. case LITERAL_void:
7643. case SCOPE:
7644. {
7645. break;
7646. }
7647. default:
7648. {
7649. throw new NoViableAltException(LT(1), getFilename());
7650. }
7651. }
7652. }
7653. simple_type_specifier();
7654. {
7655. switch ( LA(1)) {
7656. case ID:
7657. case LITERAL__stdcall:
7658. case LITERAL___stdcall:
7659. case STAR:
7660. case AMPERSAND:
7661. case SCOPE:
7662. case LITERAL__cdecl:
7663. case LITERAL___cdecl:
7664. case LITERAL__near:
7665. case LITERAL___near:
7666. case LITERAL__far:
7667. case LITERAL___far:
7668. case LITERAL___interrupt:
7669. case LITERAL_pascal:
7670. case LITERAL__pascal:
7671. case LITERAL___pascal:
7672. {
7673. ptr_operator();
7674. break;
7675. }
7676. case RPAREN:
7677. {
7678. break;
7679. }
7680. default:
7681. {
7682. throw new NoViableAltException(LT(1), getFilename());
7683. }
7684. }
7685. }
7686. match(RPAREN);
7687. }
7688. }
7689. catch (RecognitionException pe) {
7690. synPredMatched402 = false;
7691. }
7692. rewind(_m402);
7693. inputState.guessing--;
7694. }
7695. if ( synPredMatched402 ) {
7696. match(LPAREN);
7697. {
7698. switch ( LA(1)) {
7699. case LITERAL_const:
7700. case LITERAL_const_cast:
7701. case LITERAL_volatile:
7702. {
7703. type_qualifier();
7704. break;
7705. }
7706. case ID:
7707. case LITERAL__declspec:
7708. case LITERAL___declspec:
7709. case LITERAL_char:
7710. case LITERAL_wchar_t:
7711. case LITERAL_bool:
7712. case LITERAL_short:
7713. case LITERAL_int:
7714. case 44:
7715. case 45:
7716. case 46:
7717. case LITERAL_long:
7718. case LITERAL_signed:
7719. case LITERAL_unsigned:
7720. case LITERAL_float:
7721. case LITERAL_double:
7722. case LITERAL_void:
7723. case SCOPE:
7724. {
7725. break;
7726. }
7727. default:
7728. {
7729. throw new NoViableAltException(LT(1), getFilename());
7730. }
7731. }
7732. }
7733. simple_type_specifier();
7734. {
7735. switch ( LA(1)) {
7736. case ID:
7737. case LITERAL__stdcall:
7738. case LITERAL___stdcall:
7739. case STAR:
7740. case AMPERSAND:
7741. case SCOPE:
7742. case LITERAL__cdecl:
7743. case LITERAL___cdecl:
7744. case LITERAL__near:
7745. case LITERAL___near:
7746. case LITERAL__far:
7747. case LITERAL___far:
7748. case LITERAL___interrupt:
7749. case LITERAL_pascal:
7750. case LITERAL__pascal:
7751. case LITERAL___pascal:
7752. {
7753. ptr_operator();
7754. break;
7755. }
7756. case RPAREN:
7757. {
7758. break;
7759. }
7760. default:
7761. {
7762. throw new NoViableAltException(LT(1), getFilename());
7763. }
7764. }
7765. }
7766. match(RPAREN);
7767. cast_expression();
7768. }
7769. else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_43.member(LA(2)))) {
7770. unary_expression();
7771. }
7772. else {
7773. throw new NoViableAltException(LT(1), getFilename());
7774. }
7775.
7776. }
7777.
7778. public final void unary_expression() throws RecognitionException, TokenStreamException {
7779.
7780.
7781. {
7782. switch ( LA(1)) {
7783. case PLUSPLUS:
7784. {
7785. match(PLUSPLUS);
7786. unary_expression();
7787. break;
7788. }
7789. case MINUSMINUS:
7790. {
7791. match(MINUSMINUS);
7792. unary_expression();
7793. break;
7794. }
7795. case LITERAL_sizeof:
7796. {
7797. match(LITERAL_sizeof);
7798. {
7799. if (((LA(1)==LPAREN) && (_tokenSet_11.member(LA(2))))&&((!(((LA(1)==LPAREN&&(LA(2)==ID))))||(isTy...7800. match(LPAREN);
7801. type_name();
7802. match(RPAREN);
7803. }
7804. else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_43.member(LA(2)))) {
7805. unary_expression();
7806. }
7807. else {
7808. throw new NoViableAltException(LT(1), getFilename());
7809. }
7810.
7811. }
7812. break;
7813. }
7814. default:
7815. boolean synPredMatched408 = false;
7816. if (((_tokenSet_67.member(LA(1))) && (_tokenSet_68.member(LA(2))))) {
7817. int _m408 = mark();
7818. synPredMatched408 = true;
7819. inputState.guessing++;
7820. try {
7821. {
7822. postfix_expression();
7823. }
7824. }
7825. catch (RecognitionException pe) {
7826. synPredMatched408 = false;
7827. }
7828. rewind(_m408);
7829. inputState.guessing--;
7830. }
7831. if ( synPredMatched408 ) {
7832. postfix_expression();
7833. }
7834. else if ((_tokenSet_69.member(LA(1))) && (_tokenSet_42.member(LA(2)))) {
7835. unary_operator();
7836. cast_expression();
7837. }
7838. else if ((_tokenSet_70.member(LA(1))) && (_tokenSet_71.member(LA(2)))) {
7839. {
7840. switch ( LA(1)) {
7841. case SCOPE:
7842. {
7843. match(SCOPE);
7844. break;
7845. }
7846. case LITERAL_new:
7847. case LITERAL_delete:
7848. {
7849. break;
7850. }
7851. default:
7852. {
7853. throw new NoViableAltException(LT(1), getFilename());
7854. }
7855. }
7856. }
7857. {
7858. switch ( LA(1)) {
7859. case LITERAL_new:
7860. {
7861. new_expression();
7862. break;
7863. }
7864. case LITERAL_delete:
7865. {
7866. delete_expression();
7867. break;
7868. }
7869. default:
7870. {
7871. throw new NoViableAltException(LT(1), getFilename());
7872. }
7873. }
7874. }
7875. }
7876. else {
7877. throw new NoViableAltException(LT(1), getFilename());
7878. }
7879. }
7880. }
7881. }
7882.
7883. public final void postfix_expression() throws RecognitionException, TokenStreamException {
7884.
7885.
7886. {
7887. boolean synPredMatched415 = false;
7888. if ((((_tokenSet_55.member(LA(1))) && (_tokenSet_72.member(LA(2))))&&(!(LA(1)==LPAREN)))) {
7889. int _m415 = mark();
7890. synPredMatched415 = true;
7891. inputState.guessing++;
7892. try {
7893. {
7894. simple_type_specifier();
7895. match(LPAREN);
7896. match(RPAREN);
7897. match(LPAREN);
7898. }
7899. }
7900. catch (RecognitionException pe) {
7901. synPredMatched415 = false;
7902. }
7903. rewind(_m415);
7904. inputState.guessing--;
7905. }
7906. if ( synPredMatched415 ) {
7907. simple_type_specifier();
7908. match(LPAREN);
7909. match(RPAREN);
7910. match(LPAREN);
7911. {
7912. switch ( LA(1)) {
7913. case ID:
7914. case StringLiteral:
7915. case LITERAL__declspec:
7916. case LITERAL___declspec:
7917. case LPAREN:
7918. case LITERAL_const_cast:
7919. case LITERAL_char:
7920. case LITERAL_wchar_t:
7921. case LITERAL_bool:
7922. case LITERAL_short:
7923. case LITERAL_int:
7924. case 44:
7925. case 45:
7926. case 46:
7927. case LITERAL_long:
7928. case LITERAL_signed:
7929. case LITERAL_unsigned:
7930. case LITERAL_float:
7931. case LITERAL_double:
7932. case LITERAL_void:
7933. case OPERATOR:
7934. case LITERAL_this:
7935. case LITERAL_true:
7936. case LITERAL_false:
7937. case OCTALINT:
7938. case STAR:
7939. case AMPERSAND:
7940. case TILDE:
7941. case PLUS:
7942. case MINUS:
7943. case PLUSPLUS:
7944. case MINUSMINUS:
7945. case LITERAL_sizeof:
7946. case SCOPE:
7947. case LITERAL_dynamic_cast:
7948. case LITERAL_static_cast:
7949. case LITERAL_reinterpret_cast:
7950. case NOT:
7951. case LITERAL_new:
7952. case LITERAL_delete:
7953. case DECIMALINT:
7954. case HEXADECIMALINT:
7955. case CharLiteral:
7956. case FLOATONE:
7957. case FLOATTWO:
7958. {
7959. expression_list();
7960. break;
7961. }
7962. case RPAREN:
7963. {
7964. break;
7965. }
7966. default:
7967. {
7968. throw new NoViableAltException(LT(1), getFilename());
7969. }
7970. }
7971. }
7972. match(RPAREN);
7973. }
7974. else {
7975. boolean synPredMatched418 = false;
7976. if ((((_tokenSet_55.member(LA(1))) && (_tokenSet_72.member(LA(2))))&&(!(LA(1)==LPAREN)))) {
7977. int _m418 = mark();
7978. synPredMatched418 = true;
7979. inputState.guessing++;
7980. try {
7981. {
7982. simple_type_specifier();
7983. match(LPAREN);
7984. }
7985. }
7986. catch (RecognitionException pe) {
7987. synPredMatched418 = false;
7988. }
7989. rewind(_m418);
7990. inputState.guessing--;
7991. }
7992. if ( synPredMatched418 ) {
7993. simple_type_specifier();
7994. match(LPAREN);
7995. {
7996. switch ( LA(1)) {
7997. case ID:
7998. case StringLiteral:
7999. case LITERAL__declspec:
8000. case LITERAL___declspec:
8001. case LPAREN:
8002. case LITERAL_const_cast:
8003. case LITERAL_char:
8004. case LITERAL_wchar_t:
8005. case LITERAL_bool:
8006. case LITERAL_short:
8007. case LITERAL_int:
8008. case 44:
8009. case 45:
8010. case 46:
8011. case LITERAL_long:
8012. case LITERAL_signed:
8013. case LITERAL_unsigned:
8014. case LITERAL_float:
8015. case LITERAL_double:
8016. case LITERAL_void:
8017. case OPERATOR:
8018. case LITERAL_this:
8019. case LITERAL_true:
8020. case LITERAL_false:
8021. case OCTALINT:
8022. case STAR:
8023. case AMPERSAND:
8024. case TILDE:
8025. case PLUS:
8026. case MINUS:
8027. case PLUSPLUS:
8028. case MINUSMINUS:
8029. case LITERAL_sizeof:
8030. case SCOPE:
8031. case LITERAL_dynamic_cast:
8032. case LITERAL_static_cast:
8033. case LITERAL_reinterpret_cast:
8034. case NOT:
8035. case LITERAL_new:
8036. case LITERAL_delete:
8037. case DECIMALINT:
8038. case HEXADECIMALINT:
8039. case CharLiteral:
8040. case FLOATONE:
8041. case FLOATTWO:
8042. {
8043. expression_list();
8044. break;
8045. }
8046. case RPAREN:
8047. {
8048. break;
8049. }
8050. default:
8051. {
8052. throw new NoViableAltException(LT(1), getFilename());
8053. }
8054. }
8055. }
8056. match(RPAREN);
8057. }
8058. else if ((_tokenSet_73.member(LA(1))) && (_tokenSet_68.member(LA(2)))) {
8059. primary_expression();
8060. {
8061. _loop422:
8062. do {
8063. switch ( LA(1)) {
8064. case LSQUARE:
8065. {
8066. match(LSQUARE);
8067. expression();
8068. match(RSQUARE);
8069. break;
8070. }
8071. case LPAREN:
8072. {
8073. match(LPAREN);
8074. {
8075. switch ( LA(1)) {
8076. case ID:
8077. case StringLiteral:
8078. case LITERAL__declspec:
8079. case LITERAL___declspec:
8080. case LPAREN:
8081. case LITERAL_const_cast:
8082. case LITERAL_char:
8083. case LITERAL_wchar_t:
8084. case LITERAL_bool:
8085. case LITERAL_short:
8086. case LITERAL_int:
8087. case 44:
8088. case 45:
8089. case 46:
8090. case LITERAL_long:
8091. case LITERAL_signed:
8092. case LITERAL_unsigned:
8093. case LITERAL_float:
8094. case LITERAL_double:
8095. case LITERAL_void:
8096. case OPERATOR:
8097. case LITERAL_this:
8098. case LITERAL_true:
8099. case LITERAL_false:
8100. case OCTALINT:
8101. case STAR:
8102. case AMPERSAND:
8103. case TILDE:
8104. case PLUS:
8105. case MINUS:
8106. case PLUSPLUS:
8107. case MINUSMINUS:
8108. case LITERAL_sizeof:
8109. case SCOPE:
8110. case LITERAL_dynamic_cast:
8111. case LITERAL_static_cast:
8112. case LITERAL_reinterpret_cast:
8113. case NOT:
8114. case LITERAL_new:
8115. case LITERAL_delete:
8116. case DECIMALINT:
8117. case HEXADECIMALINT:
8118. case CharLiteral:
8119. case FLOATONE:
8120. case FLOATTWO:
8121. {
8122. expression_list();
8123. break;
8124. }
8125. case RPAREN:
8126. {
8127. break;
8128. }
8129. default:
8130. {
8131. throw new NoViableAltException(LT(1), getFilename());
8132. }
8133. }
8134. }
8135. match(RPAREN);
8136. break;
8137. }
8138. case DOT:
8139. {
8140. match(DOT);
8141. id_expression();
8142. break;
8143. }
8144. case POINTERTO:
8145. {
8146. match(POINTERTO);
8147. id_expression();
8148. break;
8149. }
8150. case PLUSPLUS:
8151. {
8152. match(PLUSPLUS);
8153. break;
8154. }
8155. case MINUSMINUS:
8156. {
8157. match(MINUSMINUS);
8158. break;
8159. }
8160. default:
8161. {
8162. break _loop422;
8163. }
8164. }
8165. } while (true);
8166. }
8167. }
8168. else if ((_tokenSet_74.member(LA(1)))) {
8169. {
8170. switch ( LA(1)) {
8171. case LITERAL_dynamic_cast:
8172. {
8173. match(LITERAL_dynamic_cast);
8174. break;
8175. }
8176. case LITERAL_static_cast:
8177. {
8178. match(LITERAL_static_cast);
8179. break;
8180. }
8181. case LITERAL_reinterpret_cast:
8182. {
8183. match(LITERAL_reinterpret_cast);
8184. break;
8185. }
8186. case LITERAL_const_cast:
8187. {
8188. match(LITERAL_const_cast);
8189. break;
8190. }
8191. default:
8192. {
8193. throw new NoViableAltException(LT(1), getFilename());
8194. }
8195. }
8196. }
8197. match(LESSTHAN);
8198. type_specifier();
8199. {
8200. switch ( LA(1)) {
8201. case ID:
8202. case LITERAL__stdcall:
8203. case LITERAL___stdcall:
8204. case STAR:
8205. case AMPERSAND:
8206. case SCOPE:
8207. case LITERAL__cdecl:
8208. case LITERAL___cdecl:
8209. case LITERAL__near:
8210. case LITERAL___near:
8211. case LITERAL__far:
8212. case LITERAL___far:
8213. case LITERAL___interrupt:
8214. case LITERAL_pascal:
8215. case LITERAL__pascal:
8216. case LITERAL___pascal:
8217. {
8218. ptr_operator();
8219. break;
8220. }
8221. case GREATERTHAN:
8222. {
8223. break;
8224. }
8225. default:
8226. {
8227. throw new NoViableAltException(LT(1), getFilename());
8228. }
8229. }
8230. }
8231. match(GREATERTHAN);
8232. match(LPAREN);
8233. expression();
8234. match(RPAREN);
8235. }
8236. else {
8237. throw new NoViableAltException(LT(1), getFilename());
8238. }
8239. }
8240. }
8241. }
8242.
8243. public final void unary_operator() throws RecognitionException, TokenStreamException {
8244.
8245.
8246. switch ( LA(1)) {
8247. case AMPERSAND:
8248. {
8249. match(AMPERSAND);
8250. break;
8251. }
8252. case STAR:
8253. {
8254. match(STAR);
8255. break;
8256. }
8257. case PLUS:
8258. {
8259. match(PLUS);
8260. break;
8261. }
8262. case MINUS:
8263. {
8264. match(MINUS);
8265. break;
8266. }
8267. case TILDE:
8268. {
8269. match(TILDE);
8270. break;
8271. }
8272. case NOT:
8273. {
8274. match(NOT);
8275. break;
8276. }
8277. default:
8278. {
8279. throw new NoViableAltException(LT(1), getFilename());
8280. }
8281. }
8282. }
8283.
8284. public final void new_expression() throws RecognitionException, TokenStreamException {
8285.
8286.
8287. {
8288. match(LITERAL_new);
8289. {
8290. boolean synPredMatched434 = false;
8291. if (((LA(1)==LPAREN) && (_tokenSet_42.member(LA(2))))) {
8292. int _m434 = mark();
8293. synPredMatched434 = true;
8294. inputState.guessing++;
8295. try {
8296. {
8297. match(LPAREN);
8298. expression_list();
8299. match(RPAREN);
8300. }
8301. }
8302. catch (RecognitionException pe) {
8303. synPredMatched434 = false;
8304. }
8305. rewind(_m434);
8306. inputState.guessing--;
8307. }
8308. if ( synPredMatched434 ) {
8309. match(LPAREN);
8310. expression_list();
8311. match(RPAREN);
8312. }
8313. else if ((_tokenSet_75.member(LA(1))) && (_tokenSet_76.member(LA(2)))) {
8314. }
8315. else {
8316. throw new NoViableAltException(LT(1), getFilename());
8317. }
8318.
8319. }
8320. {
8321. switch ( LA(1)) {
8322. case LITERAL_typedef:
8323. case LITERAL_enum:
8324. case ID:
8325. case LITERAL_inline:
8326. case LITERAL_extern:
8327. case LITERAL__inline:
8328. case LITERAL___inline:
8329. case LITERAL_virtual:
8330. case LITERAL_explicit:
8331. case LITERAL_friend:
8332. case LITERAL__stdcall:
8333. case LITERAL___stdcall:
8334. case LITERAL__declspec:
8335. case LITERAL___declspec:
8336. case LITERAL_typename:
8337. case LITERAL_auto:
8338. case LITERAL_register:
8339. case LITERAL_static:
8340. case LITERAL_mutable:
8341. case LITERAL_const:
8342. case LITERAL_const_cast:
8343. case LITERAL_volatile:
8344. case LITERAL_char:
8345. case LITERAL_wchar_t:
8346. case LITERAL_bool:
8347. case LITERAL_short:
8348. case LITERAL_int:
8349. case 44:
8350. case 45:
8351. case 46:
8352. case LITERAL_long:
8353. case LITERAL_signed:
8354. case LITERAL_unsigned:
8355. case LITERAL_float:
8356. case LITERAL_double:
8357. case LITERAL_void:
8358. case LITERAL_class:
8359. case LITERAL_struct:
8360. case LITERAL_union:
8361. case SCOPE:
8362. {
8363. new_type_id();
8364. break;
8365. }
8366. case LPAREN:
8367. {
8368. match(LPAREN);
8369. type_name();
8370. match(RPAREN);
8371. break;
8372. }
8373. default:
8374. {
8375. throw new NoViableAltException(LT(1), getFilename());
8376. }
8377. }
8378. }
8379. {
8380. switch ( LA(1)) {
8381. case LPAREN:
8382. {
8383. new_initializer();
8384. break;
8385. }
8386. case LESSTHAN:
8387. case GREATERTHAN:
8388. case SEMICOLON:
8389. case RCURLY:
8390. case ASSIGNEQUAL:
8391. case COLON:
8392. case COMMA:
8393. case RPAREN:
8394. case STAR:
8395. case AMPERSAND:
8396. case RSQUARE:
8397. case ELLIPSIS:
8398. case TIMESEQUAL:
8399. case DIVIDEEQUAL:
8400. case MINUSEQUAL:
8401. case PLUSEQUAL:
8402. case MODEQUAL:
8403. case SHIFTLEFTEQUAL:
8404. case SHIFTRIGHTEQUAL:
8405. case BITWISEANDEQUAL:
8406. case BITWISEXOREQUAL:
8407. case BITWISEOREQUAL:
8408. case QUESTIONMARK:
8409. case OR:
8410. case AND:
8411. case BITWISEOR:
8412. case BITWISEXOR:
8413. case NOTEQUAL:
8414. case EQUAL:
8415. case LESSTHANOREQUALTO:
8416. case GREATERTHANOREQUALTO:
8417. case SHIFTLEFT:
8418. case SHIFTRIGHT:
8419. case PLUS:
8420. case MINUS:
8421. case DIVIDE:
8422. case MOD:
8423. case DOTMBR:
8424. case POINTERTOMBR:
8425. {
8426. break;
8427. }
8428. default:
8429. {
8430. throw new NoViableAltException(LT(1), getFilename());
8431. }
8432. }
8433. }
8434. }
8435. }
8436.
8437. public final void delete_expression() throws RecognitionException, TokenStreamException {
8438.
8439.
8440. match(LITERAL_delete);
8441. {
8442. switch ( LA(1)) {
8443. case LSQUARE:
8444. {
8445. match(LSQUARE);
8446. match(RSQUARE);
8447. break;
8448. }
8449. case ID:
8450. case StringLiteral:
8451. case LITERAL__declspec:
8452. case LITERAL___declspec:
8453. case LPAREN:
8454. case LITERAL_const_cast:
8455. case LITERAL_char:
8456. case LITERAL_wchar_t:
8457. case LITERAL_bool:
8458. case LITERAL_short:
8459. case LITERAL_int:
8460. case 44:
8461. case 45:
8462. case 46:
8463. case LITERAL_long:
8464. case LITERAL_signed:
8465. case LITERAL_unsigned:
8466. case LITERAL_float:
8467. case LITERAL_double:
8468. case LITERAL_void:
8469. case OPERATOR:
8470. case LITERAL_this:
8471. case LITERAL_true:
8472. case LITERAL_false:
8473. case OCTALINT:
8474. case STAR:
8475. case AMPERSAND:
8476. case TILDE:
8477. case PLUS:
8478. case MINUS:
8479. case PLUSPLUS:
8480. case MINUSMINUS:
8481. case LITERAL_sizeof:
8482. case SCOPE:
8483. case LITERAL_dynamic_cast:
8484. case LITERAL_static_cast:
8485. case LITERAL_reinterpret_cast:
8486. case NOT:
8487. case LITERAL_new:
8488. case LITERAL_delete:
8489. case DECIMALINT:
8490. case HEXADECIMALINT:
8491. case CharLiteral:
8492. case FLOATONE:
8493. case FLOATTWO:
8494. {
8495. break;
8496. }
8497. default:
8498. {
8499. throw new NoViableAltException(LT(1), getFilename());
8500. }
8501. }
8502. }
8503. cast_expression();
8504. }
8505.
8506. public final void primary_expression() throws RecognitionException, TokenStreamException {
8507.
8508.
8509. switch ( LA(1)) {
8510. case ID:
8511. case OPERATOR:
8512. case TILDE:
8513. case SCOPE:
8514. {
8515. id_expression();
8516. break;
8517. }
8518. case StringLiteral:
8519. case LITERAL_true:
8520. case LITERAL_false:
8521. case OCTALINT:
8522. case DECIMALINT:
8523. case HEXADECIMALINT:
8524. case CharLiteral:
8525. case FLOATONE:
8526. case FLOATTWO:
8527. {
8528. constant();
8529. break;
8530. }
8531. case LITERAL_this:
8532. {
8533. match(LITERAL_this);
8534. break;
8535. }
8536. case LPAREN:
8537. {
8538. match(LPAREN);
8539. expression();
8540. match(RPAREN);
8541. break;
8542. }
8543. default:
8544. {
8545. throw new NoViableAltException(LT(1), getFilename());
8546. }
8547. }
8548. }
8549.
8550. public final void id_expression() throws RecognitionException, TokenStreamException {
8551.
8552. String s="";
8553.
8554. s=scope_override();
8555. {
8556. switch ( LA(1)) {
8557. case ID:
8558. {
8559. match(ID);
8560. break;
8561. }
8562. case OPERATOR:
8563. {
8564. match(OPERATOR);
8565. optor();
8566. break;
8567. }
8568. case TILDE:
8569. {
8570. match(TILDE);
8571. {
8572. switch ( LA(1)) {
8573. case STAR:
8574. {
8575. match(STAR);
8576. break;
8577. }
8578. case ID:
8579. {
8580. break;
8581. }
8582. default:
8583. {
8584. throw new NoViableAltException(LT(1), getFilename());
8585. }
8586. }
8587. }
8588. match(ID);
8589. break;
8590. }
8591. default:
8592. {
8593. throw new NoViableAltException(LT(1), getFilename());
8594. }
8595. }
8596. }
8597. }
8598.
8599. public final void constant() throws RecognitionException, TokenStreamException {
8600.
8601.
8602. switch ( LA(1)) {
8603. case OCTALINT:
8604. {
8605. match(OCTALINT);
8606. break;
8607. }
8608. case DECIMALINT:
8609. {
8610. match(DECIMALINT);
8611. break;
8612. }
8613. case HEXADECIMALINT:
8614. {
8615. match(HEXADECIMALINT);
8616. break;
8617. }
8618. case CharLiteral:
8619. {
8620. match(CharLiteral);
8621. break;
8622. }
8623. case StringLiteral:
8624. {
8625. {
8626. int _cnt468=0;
8627. _loop468:
8628. do {
8629. if ((LA(1)==StringLiteral)) {
8630. match(StringLiteral);
8631. }
8632. else {
8633. if ( _cnt468>=1 ) { break _loop468; } else {throw new NoViableAltException(LT(1), getFilename()...8634. }
8635.
8636. _cnt468++;
8637. } while (true);
8638. }
8639. break;
8640. }
8641. case FLOATONE:
8642. {
8643. match(FLOATONE);
8644. break;
8645. }
8646. case FLOATTWO:
8647. {
8648. match(FLOATTWO);
8649. break;
8650. }
8651. case LITERAL_true:
8652. {
8653. match(LITERAL_true);
8654. break;
8655. }
8656. case LITERAL_false:
8657. {
8658. match(LITERAL_false);
8659. break;
8660. }
8661. default:
8662. {
8663. throw new NoViableAltException(LT(1), getFilename());
8664. }
8665. }
8666. }
8667.
8668. public final void new_type_id() throws RecognitionException, TokenStreamException {
8669.
8670.
8671. declaration_specifiers();
8672. {
8673. if ((_tokenSet_77.member(LA(1))) && (_tokenSet_78.member(LA(2)))) {
8674. new_declarator();
8675. }
8676. else if ((_tokenSet_79.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
8677. }
8678. else {
8679. throw new NoViableAltException(LT(1), getFilename());
8680. }
8681.
8682. }
8683. }
8684.
8685. public final void new_initializer() throws RecognitionException, TokenStreamException {
8686.
8687.
8688. match(LPAREN);
8689. {
8690. switch ( LA(1)) {
8691. case ID:
8692. case StringLiteral:
8693. case LITERAL__declspec:
8694. case LITERAL___declspec:
8695. case LPAREN:
8696. case LITERAL_const_cast:
8697. case LITERAL_char:
8698. case LITERAL_wchar_t:
8699. case LITERAL_bool:
8700. case LITERAL_short:
8701. case LITERAL_int:
8702. case 44:
8703. case 45:
8704. case 46:
8705. case LITERAL_long:
8706. case LITERAL_signed:
8707. case LITERAL_unsigned:
8708. case LITERAL_float:
8709. case LITERAL_double:
8710. case LITERAL_void:
8711. case OPERATOR:
8712. case LITERAL_this:
8713. case LITERAL_true:
8714. case LITERAL_false:
8715. case OCTALINT:
8716. case STAR:
8717. case AMPERSAND:
8718. case TILDE:
8719. case PLUS:
8720. case MINUS:
8721. case PLUSPLUS:
8722. case MINUSMINUS:
8723. case LITERAL_sizeof:
8724. case SCOPE:
8725. case LITERAL_dynamic_cast:
8726. case LITERAL_static_cast:
8727. case LITERAL_reinterpret_cast:
8728. case NOT:
8729. case LITERAL_new:
8730. case LITERAL_delete:
8731. case DECIMALINT:
8732. case HEXADECIMALINT:
8733. case CharLiteral:
8734. case FLOATONE:
8735. case FLOATTWO:
8736. {
8737. expression_list();
8738. break;
8739. }
8740. case RPAREN:
8741. {
8742. break;
8743. }
8744. default:
8745. {
8746. throw new NoViableAltException(LT(1), getFilename());
8747. }
8748. }
8749. }
8750. match(RPAREN);
8751. }
8752.
8753. public final void new_declarator() throws RecognitionException, TokenStreamException {
8754.
8755.
8756. switch ( LA(1)) {
8757. case ID:
8758. case LITERAL__stdcall:
8759. case LITERAL___stdcall:
8760. case STAR:
8761. case AMPERSAND:
8762. case SCOPE:
8763. case LITERAL__cdecl:
8764. case LITERAL___cdecl:
8765. case LITERAL__near:
8766. case LITERAL___near:
8767. case LITERAL__far:
8768. case LITERAL___far:
8769. case LITERAL___interrupt:
8770. case LITERAL_pascal:
8771. case LITERAL__pascal:
8772. case LITERAL___pascal:
8773. {
8774. ptr_operator();
8775. {
8776. if ((_tokenSet_77.member(LA(1))) && (_tokenSet_78.member(LA(2)))) {
8777. new_declarator();
8778. }
8779. else if ((_tokenSet_79.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
8780. }
8781. else {
8782. throw new NoViableAltException(LT(1), getFilename());
8783. }
8784.
8785. }
8786. break;
8787. }
8788. case LSQUARE:
8789. {
8790. direct_new_declarator();
8791. break;
8792. }
8793. default:
8794. {
8795. throw new NoViableAltException(LT(1), getFilename());
8796. }
8797. }
8798. }
8799.
8800. public final void direct_new_declarator() throws RecognitionException, TokenStreamException {
8801.
8802.
8803. {
8804. int _cnt460=0;
8805. _loop460:
8806. do {
8807. if ((LA(1)==LSQUARE)) {
8808. match(LSQUARE);
8809. expression();
8810. match(RSQUARE);
8811. }
8812. else {
8813. if ( _cnt460>=1 ) { break _loop460; } else {throw new NoViableAltException(LT(1), getFilename())...8814. }
8815.
8816. _cnt460++;
8817. } while (true);
8818. }
8819. }
8820.
8821. public final void ptr_to_member() throws RecognitionException, TokenStreamException {
8822.
8823. String s="";
8824.
8825. s=scope_override();
8826. match(STAR);
8827. if ( inputState.guessing==0 ) {
8828.
8829. if (s.length() != 0) m.ptrToMember(s, "*");
8830. else m.ptrOperator("*");
8831.
8832. }
8833. cv_qualifier_seq();
8834. }
8835.
8836. public final void optor_simple_tokclass() throws RecognitionException, TokenStreamException {
8837.
8838.
8839. {
8840. switch ( LA(1)) {
8841. case PLUS:
8842. {
8843. match(PLUS);
8844. break;
8845. }
8846. case MINUS:
8847. {
8848. match(MINUS);
8849. break;
8850. }
8851. case STAR:
8852. {
8853. match(STAR);
8854. break;
8855. }
8856. case DIVIDE:
8857. {
8858. match(DIVIDE);
8859. break;
8860. }
8861. case MOD:
8862. {
8863. match(MOD);
8864. break;
8865. }
8866. case BITWISEXOR:
8867. {
8868. match(BITWISEXOR);
8869. break;
8870. }
8871. case AMPERSAND:
8872. {
8873. match(AMPERSAND);
8874. break;
8875. }
8876. case BITWISEOR:
8877. {
8878. match(BITWISEOR);
8879. break;
8880. }
8881. case TILDE:
8882. {
8883. match(TILDE);
8884. break;
8885. }
8886. case NOT:
8887. {
8888. match(NOT);
8889. break;
8890. }
8891. case SHIFTLEFT:
8892. {
8893. match(SHIFTLEFT);
8894. break;
8895. }
8896. case SHIFTRIGHT:
8897. {
8898. match(SHIFTRIGHT);
8899. break;
8900. }
8901. case ASSIGNEQUAL:
8902. {
8903. match(ASSIGNEQUAL);
8904. break;
8905. }
8906. case TIMESEQUAL:
8907. {
8908. match(TIMESEQUAL);
8909. break;
8910. }
8911. case DIVIDEEQUAL:
8912. {
8913. match(DIVIDEEQUAL);
8914. break;
8915. }
8916. case MODEQUAL:
8917. {
8918. match(MODEQUAL);
8919. break;
8920. }
8921. case PLUSEQUAL:
8922. {
8923. match(PLUSEQUAL);
8924. break;
8925. }
8926. case MINUSEQUAL:
8927. {
8928. match(MINUSEQUAL);
8929. break;
8930. }
8931. case SHIFTLEFTEQUAL:
8932. {
8933. match(SHIFTLEFTEQUAL);
8934. break;
8935. }
8936. case SHIFTRIGHTEQUAL:
8937. {
8938. match(SHIFTRIGHTEQUAL);
8939. break;
8940. }
8941. case BITWISEANDEQUAL:
8942. {
8943. match(BITWISEANDEQUAL);
8944. break;
8945. }
8946. case BITWISEXOREQUAL:
8947. {
8948. match(BITWISEXOREQUAL);
8949. break;
8950. }
8951. case BITWISEOREQUAL:
8952. {
8953. match(BITWISEOREQUAL);
8954. break;
8955. }
8956. case EQUAL:
8957. {
8958. match(EQUAL);
8959. break;
8960. }
8961. case NOTEQUAL:
8962. {
8963. match(NOTEQUAL);
8964. break;
8965. }
8966. case LESSTHAN:
8967. {
8968. match(LESSTHAN);
8969. break;
8970. }
8971. case GREATERTHAN:
8972. {
8973. match(GREATERTHAN);
8974. break;
8975. }
8976. case LESSTHANOREQUALTO:
8977. {
8978. match(LESSTHANOREQUALTO);
8979. break;
8980. }
8981. case GREATERTHANOREQUALTO:
8982. {
8983. match(GREATERTHANOREQUALTO);
8984. break;
8985. }
8986. case OR:
8987. {
8988. match(OR);
8989. break;
8990. }
8991. case AND:
8992. {
8993. match(AND);
8994. break;
8995. }
8996. case PLUSPLUS:
8997. {
8998. match(PLUSPLUS);
8999. break;
9000. }
9001. case MINUSMINUS:
9002. {
9003. match(MINUSMINUS);
9004. break;
9005. }
9006. case COMMA:
9007. {
9008. match(COMMA);
9009. break;
9010. }
9011. case POINTERTO:
9012. {
9013. match(POINTERTO);
9014. break;
9015. }
9016. case POINTERTOMBR:
9017. {
9018. match(POINTERTOMBR);
9019. break;
9020. }
9021. default:
9022. {
9023. throw new NoViableAltException(LT(1), getFilename());
9024. }
9025. }
9026. }
9027. }
9028.
9029.
9030. public static final String[] _tokenNames = {
9031. "<0>",
9032. "EOF",
9033. "<2>",
9034. "NULL_TREE_LOOKAHEAD",
9035. "\"template\"",
9036. "LESSTHAN",
9037. "GREATERTHAN",
9038. "\"typedef\"",
9039. "\"enum\"",
9040. "ID",
9041. "LCURLY",
9042. "SEMICOLON",
9043. "\"inline\"",
9044. "\"namespace\"",
9045. "RCURLY",
9046. "ASSIGNEQUAL",
9047. "COLON",
9048. "\"extern\"",
9049. "StringLiteral",
9050. "COMMA",
9051. "\"_inline\"",
9052. "\"__inline\"",
9053. "\"virtual\"",
9054. "\"explicit\"",
9055. "\"friend\"",
9056. "\"_stdcall\"",
9057. "\"__stdcall\"",
9058. "\"_declspec\"",
9059. "\"__declspec\"",
9060. "LPAREN",
9061. "RPAREN",
9062. "\"typename\"",
9063. "\"auto\"",
9064. "\"register\"",
9065. "\"static\"",
9066. "\"mutable\"",
9067. "\"const\"",
9068. "\"const_cast\"",
9069. "\"volatile\"",
9070. "\"char\"",
9071. "\"wchar_t\"",
9072. "\"bool\"",
9073. "\"short\"",
9074. "\"int\"",
9075. "\"_int64\"",
9076. "\"__int64\"",
9077. "\"__w64\"",
9078. "\"long\"",
9079. "\"signed\"",
9080. "\"unsigned\"",
9081. "\"float\"",
9082. "\"double\"",
9083. "\"void\"",
9084. "\"class\"",
9085. "\"struct\"",
9086. "\"union\"",
9087. "\"operator\"",
9088. "\"this\"",
9089. "\"true\"",
9090. "\"false\"",
9091. "\"public\"",
9092. "\"protected\"",
9093. "\"private\"",
9094. "OCTALINT",
9095. "STAR",
9096. "AMPERSAND",
9097. "LSQUARE",
9098. "RSQUARE",
9099. "TILDE",
9100. "ELLIPSIS",
9101. "\"throw\"",
9102. "\"case\"",
9103. "\"default\"",
9104. "\"if\"",
9105. "\"else\"",
9106. "\"switch\"",
9107. "\"while\"",
9108. "\"do\"",
9109. "\"for\"",
9110. "\"goto\"",
9111. "\"continue\"",
9112. "\"break\"",
9113. "\"return\"",
9114. "\"try\"",
9115. "\"catch\"",
9116. "\"using\"",
9117. "\"_asm\"",
9118. "\"__asm\"",
9119. "TIMESEQUAL",
9120. "DIVIDEEQUAL",
9121. "MINUSEQUAL",
9122. "PLUSEQUAL",
9123. "MODEQUAL",
9124. "SHIFTLEFTEQUAL",
9125. "SHIFTRIGHTEQUAL",
9126. "BITWISEANDEQUAL",
9127. "BITWISEXOREQUAL",
9128. "BITWISEOREQUAL",
9129. "QUESTIONMARK",
9130. "OR",
9131. "AND",
9132. "BITWISEOR",
9133. "BITWISEXOR",
9134. "NOTEQUAL",
9135. "EQUAL",
9136. "LESSTHANOREQUALTO",
9137. "GREATERTHANOREQUALTO",
9138. "SHIFTLEFT",
9139. "SHIFTRIGHT",
9140. "PLUS",
9141. "MINUS",
9142. "DIVIDE",
9143. "MOD",
9144. "DOTMBR",
9145. "POINTERTOMBR",
9146. "PLUSPLUS",
9147. "MINUSMINUS",
9148. "\"sizeof\"",
9149. "SCOPE",
9150. "DOT",
9151. "POINTERTO",
9152. "\"dynamic_cast\"",
9153. "\"static_cast\"",
9154. "\"reinterpret_cast\"",
9155. "NOT",
9156. "\"new\"",
9157. "\"_cdecl\"",
9158. "\"__cdecl\"",
9159. "\"_near\"",
9160. "\"__near\"",
9161. "\"_far\"",
9162. "\"__far\"",
9163. "\"__interrupt\"",
9164. "\"pascal\"",
9165. "\"_pascal\"",
9166. "\"__pascal\"",
9167. "\"delete\"",
9168. "DECIMALINT",
9169. "HEXADECIMALINT",
9170. "CharLiteral",
9171. "FLOATONE",
9172. "FLOATTWO",
9173. "Whitespace",
9174. "Comment",
9175. "CPPComment",
9176. "DIRECTIVE",
9177. "LineDirective",
9178. "EndOfLine",
9179. "Escape",
9180. "Digit",
9181. "Decimal",
9182. "LongSuffix",
9183. "UnsignedSuffix",
9184. "FloatSuffix",
9185. "Exponent",
9186. "Vocabulary",
9187. "Number"
9188. };
9189.
9190. private static final long[] mk_tokenSet_0() {
9191. long[] data = { 1152921503532202896L, -4593671619915808749L, 255L, 0L, 0L, 0L};
9192. return data;
9193. }
9194. public static final BitSet _tokenSet_0 = new BitSet(mk_tokenSet_0());
9195. private static final long[] mk_tokenSet_1() {
9196. long[] data = { 72057592426402688L, 18014398511579136L, 0L, 0L};
9197. return data;
9198. }
9199. public static final BitSet _tokenSet_1 = new BitSet(mk_tokenSet_1());
9200. private static final long[] mk_tokenSet_2() {
9201. long[] data = { 1152921501385506720L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9202. return data;
9203. }
9204. public static final BitSet _tokenSet_2 = new BitSet(mk_tokenSet_2());
9205. private static final long[] mk_tokenSet_3() {
9206. long[] data = { 7344656L, 18014398509482000L, 0L, 0L};
9207. return data;
9208. }
9209. public static final BitSet _tokenSet_3 = new BitSet(mk_tokenSet_3());
9210. private static final long[] mk_tokenSet_4() {
9211. long[] data = { 7344672L, 18014398509482000L, 0L, 0L};
9212. return data;
9213. }
9214. public static final BitSet _tokenSet_4 = new BitSet(mk_tokenSet_4());
9215. private static final long[] mk_tokenSet_5() {
9216. long[] data = { 11538944L, 18014398509481984L, 0L, 0L};
9217. return data;
9218. }
9219. public static final BitSet _tokenSet_5 = new BitSet(mk_tokenSet_5());
9220. private static final long[] mk_tokenSet_6() {
9221. long[] data = { 548409888L, 18014398509481984L, 0L, 0L};
9222. return data;
9223. }
9224. public static final BitSet _tokenSet_6 = new BitSet(mk_tokenSet_6());
9225. private static final long[] mk_tokenSet_7() {
9226. long[] data = { 72057594037932544L, 18014398509481984L, 0L, 0L};
9227. return data;
9228. }
9229. public static final BitSet _tokenSet_7 = new BitSet(mk_tokenSet_7());
9230. private static final long[] mk_tokenSet_8() {
9231. long[] data = { 144115186464330656L, 18014398509481984L, 0L, 0L};
9232. return data;
9233. }
9234. public static final BitSet _tokenSet_8 = new BitSet(mk_tokenSet_8());
9235. private static final long[] mk_tokenSet_9() {
9236. long[] data = { 1152921503532192640L, -4593671619917905917L, 255L, 0L, 0L, 0L};
9237. return data;
9238. }
9239. public static final BitSet _tokenSet_9 = new BitSet(mk_tokenSet_9());
9240. private static final long[] mk_tokenSet_10() {
9241. long[] data = { 1152921501385267168L, -1054405279954763753L, 511L, 0L, 0L, 0L};
9242. return data;
9243. }
9244. public static final BitSet _tokenSet_10 = new BitSet(mk_tokenSet_10());
9245. private static final long[] mk_tokenSet_11() {
9246. long[] data = { 72057592426402688L, 18014398509481984L, 0L, 0L};
9247. return data;
9248. }
9249. public static final BitSet _tokenSet_11 = new BitSet(mk_tokenSet_11());
9250. private static final long[] mk_tokenSet_12() {
9251. long[] data = { 1152921501385236384L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9252. return data;
9253. }
9254. public static final BitSet _tokenSet_12 = new BitSet(mk_tokenSet_12());
9255. private static final long[] mk_tokenSet_13() {
9256. long[] data = { 100663808L, -4593671619917905917L, 255L, 0L, 0L, 0L};
9257. return data;
9258. }
9259. public static final BitSet _tokenSet_13 = new BitSet(mk_tokenSet_13());
9260. private static final long[] mk_tokenSet_14() {
9261. long[] data = { 1080864392242790944L, -4593671619917905917L, 255L, 0L, 0L, 0L};
9262. return data;
9263. }
9264. public static final BitSet _tokenSet_14 = new BitSet(mk_tokenSet_14());
9265. private static final long[] mk_tokenSet_15() {
9266. long[] data = { 1080863911105790464L, 18014398509481984L, 0L, 0L};
9267. return data;
9268. }
9269. public static final BitSet _tokenSet_15 = new BitSet(mk_tokenSet_15());
9270. private static final long[] mk_tokenSet_16() {
9271. long[] data = { 1080863911106347616L, 3557280738472624151L, 256L, 0L, 0L, 0L};
9272. return data;
9273. }
9274. public static final BitSet _tokenSet_16 = new BitSet(mk_tokenSet_16());
9275. private static final long[] mk_tokenSet_17() {
9276. long[] data = { 1152921501384710048L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9277. return data;
9278. }
9279. public static final BitSet _tokenSet_17 = new BitSet(mk_tokenSet_17());
9280. private static final long[] mk_tokenSet_18() {
9281. long[] data = { 72057592426403712L, 18014398511579136L, 0L, 0L};
9282. return data;
9283. }
9284. public static final BitSet _tokenSet_18 = new BitSet(mk_tokenSet_18());
9285. private static final long[] mk_tokenSet_19() {
9286. long[] data = { -8070450533321769056L, -110232637738583085L, 16383L, 0L, 0L, 0L};
9287. return data;
9288. }
9289. public static final BitSet _tokenSet_19 = new BitSet(mk_tokenSet_19());
9290. private static final long[] mk_tokenSet_20() {
9291. long[] data = { -8070450533322301568L, 4501453380688804819L, 16128L, 0L, 0L, 0L};
9292. return data;
9293. }
9294. public static final BitSet _tokenSet_20 = new BitSet(mk_tokenSet_20());
9295. private static final long[] mk_tokenSet_21() {
9296. long[] data = { 1080863911206453760L, -4593671619917905917L, 255L, 0L, 0L, 0L};
9297. return data;
9298. }
9299. public static final BitSet _tokenSet_21 = new BitSet(mk_tokenSet_21());
9300. private static final long[] mk_tokenSet_22() {
9301. long[] data = { 1080864392243348064L, -1054405279954763753L, 511L, 0L, 0L, 0L};
9302. return data;
9303. }
9304. public static final BitSet _tokenSet_22 = new BitSet(mk_tokenSet_22());
9305. private static final long[] mk_tokenSet_23() {
9306. long[] data = { 1152921503532220304L, -4593671619915808749L, 255L, 0L, 0L, 0L};
9307. return data;
9308. }
9309. public static final BitSet _tokenSet_23 = new BitSet(mk_tokenSet_23());
9310. private static final long[] mk_tokenSet_24() {
9311. long[] data = { -8070450533322321024L, 4501453380673077267L, 16128L, 0L, 0L, 0L};
9312. return data;
9313. }
9314. public static final BitSet _tokenSet_24 = new BitSet(mk_tokenSet_24());
9315. private static final long[] mk_tokenSet_25() {
9316. long[] data = { 1080863912280837728L, -4591419820120997825L, 255L, 0L, 0L, 0L};
9317. return data;
9318. }
9319. public static final BitSet _tokenSet_25 = new BitSet(mk_tokenSet_25());
9320. private static final long[] mk_tokenSet_26() {
9321. long[] data = { -14L, -1048577L, 16383L, 0L, 0L, 0L};
9322. return data;
9323. }
9324. public static final BitSet _tokenSet_26 = new BitSet(mk_tokenSet_26());
9325. private static final long[] mk_tokenSet_27() {
9326. long[] data = { 7344640L, 18014398509482000L, 0L, 0L};
9327. return data;
9328. }
9329. public static final BitSet _tokenSet_27 = new BitSet(mk_tokenSet_27());
9330. private static final long[] mk_tokenSet_28() {
9331. long[] data = { 144115186464330624L, 18014398509481984L, 0L, 0L};
9332. return data;
9333. }
9334. public static final BitSet _tokenSet_28 = new BitSet(mk_tokenSet_28());
9335. private static final long[] mk_tokenSet_29() {
9336. long[] data = { 1080863910568919552L, 18014398509481984L, 0L, 0L};
9337. return data;
9338. }
9339. public static final BitSet _tokenSet_29 = new BitSet(mk_tokenSet_29());
9340. private static final long[] mk_tokenSet_30() {
9341. long[] data = { 1080863911106349664L, 3557280738472624151L, 256L, 0L, 0L, 0L};
9342. return data;
9343. }
9344. public static final BitSet _tokenSet_30 = new BitSet(mk_tokenSet_30());
9345. private static final long[] mk_tokenSet_31() {
9346. long[] data = { 1152921501384777632L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9347. return data;
9348. }
9349. public static final BitSet _tokenSet_31 = new BitSet(mk_tokenSet_31());
9350. private static final long[] mk_tokenSet_32() {
9351. long[] data = { -8133501338408189440L, 4501453380673077275L, 16128L, 0L, 0L, 0L};
9352. return data;
9353. }
9354. public static final BitSet _tokenSet_32 = new BitSet(mk_tokenSet_32());
9355. private static final long[] mk_tokenSet_33() {
9356. long[] data = { 1080863912280836704L, -1053842312821473217L, 511L, 0L, 0L, 0L};
9357. return data;
9358. }
9359. public static final BitSet _tokenSet_33 = new BitSet(mk_tokenSet_33());
9360. private static final long[] mk_tokenSet_34() {
9361. long[] data = { 9006649901580288L, 0L, 0L};
9362. return data;
9363. }
9364. public static final BitSet _tokenSet_34 = new BitSet(mk_tokenSet_34());
9365. private static final long[] mk_tokenSet_35() {
9366. long[] data = { 9223372035780139920L, -4593671619915808749L, 255L, 0L, 0L, 0L};
9367. return data;
9368. }
9369. public static final BitSet _tokenSet_35 = new BitSet(mk_tokenSet_35());
9370. private static final long[] mk_tokenSet_36() {
9371. long[] data = { 9223372035780123536L, -4593671619915808749L, 255L, 0L, 0L, 0L};
9372. return data;
9373. }
9374. public static final BitSet _tokenSet_36 = new BitSet(mk_tokenSet_36());
9375. private static final long[] mk_tokenSet_37() {
9376. long[] data = { 1080863912280836704L, -4591419820120997825L, 255L, 0L, 0L, 0L};
9377. return data;
9378. }
9379. public static final BitSet _tokenSet_37 = new BitSet(mk_tokenSet_37());
9380. private static final long[] mk_tokenSet_38() {
9381. long[] data = { 1080863912280837728L, -4476578029623050177L, 255L, 0L, 0L, 0L};
9382. return data;
9383. }
9384. public static final BitSet _tokenSet_38 = new BitSet(mk_tokenSet_38());
9385. private static final long[] mk_tokenSet_39() {
9386. long[] data = { 1080864392242790944L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9387. return data;
9388. }
9389. public static final BitSet _tokenSet_39 = new BitSet(mk_tokenSet_39());
9390. private static final long[] mk_tokenSet_40() {
9391. long[] data = { 1080863911105790464L, 18014398509482000L, 0L, 0L};
9392. return data;
9393. }
9394. public static final BitSet _tokenSet_40 = new BitSet(mk_tokenSet_40());
9395. private static final long[] mk_tokenSet_41() {
9396. long[] data = { 1080863912280754784L, -1054405279954763721L, 511L, 0L, 0L, 0L};
9397. return data;
9398. }
9399. public static final BitSet _tokenSet_41 = new BitSet(mk_tokenSet_41());
9400. private static final long[] mk_tokenSet_42() {
9401. long[] data = { -8133501338408189440L, 4501453380673077267L, 16128L, 0L, 0L, 0L};
9402. return data;
9403. }
9404. public static final BitSet _tokenSet_42 = new BitSet(mk_tokenSet_42());
9405. private static final long[] mk_tokenSet_43() {
9406. long[] data = { -8070450532247938080L, 4611686018410610751L, 16128L, 0L, 0L, 0L};
9407. return data;
9408. }
9409. public static final BitSet _tokenSet_43 = new BitSet(mk_tokenSet_43());
9410. private static final long[] mk_tokenSet_44() {
9411. long[] data = { -8133501338408123904L, 4501453380673077267L, 16128L, 0L, 0L, 0L};
9412. return data;
9413. }
9414. public static final BitSet _tokenSet_44 = new BitSet(mk_tokenSet_44());
9415. private static final long[] mk_tokenSet_45() {
9416. long[] data = { 1080863911206453760L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9417. return data;
9418. }
9419. public static final BitSet _tokenSet_45 = new BitSet(mk_tokenSet_45());
9420. private static final long[] mk_tokenSet_46() {
9421. long[] data = { 1080864392243350112L, -1054405279954763753L, 511L, 0L, 0L, 0L};
9422. return data;
9423. }
9424. public static final BitSet _tokenSet_46 = new BitSet(mk_tokenSet_46());
9425. private static final long[] mk_tokenSet_47() {
9426. long[] data = { 72057592426438528L, 18014398511579200L, 0L, 0L};
9427. return data;
9428. }
9429. public static final BitSet _tokenSet_47 = new BitSet(mk_tokenSet_47());
9430. private static final long[] mk_tokenSet_48() {
9431. long[] data = { 1152921502459008992L, -4593671619917905865L, 255L, 0L, 0L, 0L};
9432. return data;
9433. }
9434. public static final BitSet _tokenSet_48 = new BitSet(mk_tokenSet_48());
9435. private static final long[] mk_tokenSet_49() {
9436. long[] data = { 1080864393317089888L, -1054405279954763721L, 511L, 0L, 0L, 0L};
9437. return data;
9438. }
9439. public static final BitSet _tokenSet_49 = new BitSet(mk_tokenSet_49());
9440. private static final long[] mk_tokenSet_50() {
9441. long[] data = { 1711833664L, -4593671619917905881L, 255L, 0L, 0L, 0L};
9442. return data;
9443. }
9444. public static final BitSet _tokenSet_50 = new BitSet(mk_tokenSet_50());
9445. private static final long[] mk_tokenSet_51() {
9446. long[] data = { -8070450532247937056L, -108086391071571841L, 16383L, 0L, 0L, 0L};
9447. return data;
9448. }
9449. public static final BitSet _tokenSet_51 = new BitSet(mk_tokenSet_51());
9450. private static final long[] mk_tokenSet_52() {
9451. long[] data = { 524864L, 0L, 0L};
9452. return data;
9453. }
9454. public static final BitSet _tokenSet_52 = new BitSet(mk_tokenSet_52());
9455. private static final long[] mk_tokenSet_53() {
9456. long[] data = { 1152921503532192640L, -4593671619917905869L, 255L, 0L, 0L, 0L};
9457. return data;
9458. }
9459. public static final BitSet _tokenSet_53 = new BitSet(mk_tokenSet_53());
9460. private static final long[] mk_tokenSet_54() {
9461. long[] data = { 638059104L, -4593671619917905913L, 255L, 0L, 0L, 0L};
9462. return data;
9463. }
9464. public static final BitSet _tokenSet_54 = new BitSet(mk_tokenSet_54());
9465. private static final long[] mk_tokenSet_55() {
9466. long[] data = { 9006649901580800L, 18014398509481984L, 0L, 0L};
9467. return data;
9468. }
9469. public static final BitSet _tokenSet_55 = new BitSet(mk_tokenSet_55());
9470. private static final long[] mk_tokenSet_56() {
9471. long[] data = { 9006650539639392L, -4593671619917905913L, 255L, 0L, 0L, 0L};
9472. return data;
9473. }
9474. public static final BitSet _tokenSet_56 = new BitSet(mk_tokenSet_56());
9475. private static final long[] mk_tokenSet_57() {
9476. long[] data = { 1152921501385234400L, -4593671619917905897L, 255L, 0L, 0L, 0L};
9477. return data;
9478. }
9479. public static final BitSet _tokenSet_57 = new BitSet(mk_tokenSet_57());
9480. private static final long[] mk_tokenSet_58() {
9481. long[] data = { -8070450533321763872L, 4611686001230741527L, 16128L, 0L, 0L, 0L};
9482. return data;
9483. }
9484. public static final BitSet _tokenSet_58 = new BitSet(mk_tokenSet_58());
9485. private static final long[] mk_tokenSet_59() {
9486. long[] data = { -8070450533322317952L, 4501453380688804819L, 16128L, 0L, 0L, 0L};
9487. return data;
9488. }
9489. public static final BitSet _tokenSet_59 = new BitSet(mk_tokenSet_59());
9490. private static final long[] mk_tokenSet_60() {
9491. long[] data = { -8070450533321761824L, 4611686018410610711L, 16128L, 0L, 0L, 0L};
9492. return data;
9493. }
9494. public static final BitSet _tokenSet_60 = new BitSet(mk_tokenSet_60());
9495. private static final long[] mk_tokenSet_61() {
9496. long[] data = { -8070450533322301568L, 4501453380688805843L, 16128L, 0L, 0L, 0L};
9497. return data;
9498. }
9499. public static final BitSet _tokenSet_61 = new BitSet(mk_tokenSet_61());
9500. private static final long[] mk_tokenSet_62() {
9501. long[] data = { -1073741838L, -41L, 16383L, 0L, 0L, 0L};
9502. return data;
9503. }
9504. public static final BitSet _tokenSet_62 = new BitSet(mk_tokenSet_62());
9505. private static final long[] mk_tokenSet_63() {
9506. long[] data = { -16400L, -1L, 536870911L, 0L, 0L, 0L};
9507. return data;
9508. }
9509. public static final BitSet _tokenSet_63 = new BitSet(mk_tokenSet_63());
9510. private static final long[] mk_tokenSet_64() {
9511. long[] data = { 96L, 6597069766656L, 0L, 0L};
9512. return data;
9513. }
9514. public static final BitSet _tokenSet_64 = new BitSet(mk_tokenSet_64());
9515. private static final long[] mk_tokenSet_65() {
9516. long[] data = { 0L, 422212465065985L, 0L, 0L};
9517. return data;
9518. }
9519. public static final BitSet _tokenSet_65 = new BitSet(mk_tokenSet_65());
9520. private static final long[] mk_tokenSet_66() {
9521. long[] data = { 9007130937917952L, 18014398509481984L, 0L, 0L};
9522. return data;
9523. }
9524. public static final BitSet _tokenSet_66 = new BitSet(mk_tokenSet_66());
9525. private static final long[] mk_tokenSet_67() {
9526. long[] data = { -8133501338408189440L, 1026820715040473104L, 15872L, 0L, 0L, 0L};
9527. return data;
9528. }
9529. public static final BitSet _tokenSet_67 = new BitSet(mk_tokenSet_67());
9530. private static final long[] mk_tokenSet_68() {
9531. long[] data = { -8133501337333806496L, 4611686018410610751L, 16128L, 0L, 0L, 0L};
9532. return data;
9533. }
9534. public static final BitSet _tokenSet_68 = new BitSet(mk_tokenSet_68());
9535. private static final long[] mk_tokenSet_69() {
9536. long[] data = { 0L, 1153027057723113491L, 0L, 0L};
9537. return data;
9538. }
9539. public static final BitSet _tokenSet_69 = new BitSet(mk_tokenSet_69());
9540. private static final long[] mk_tokenSet_70() {
9541. long[] data = { 0L, 2323857407723175936L, 256L, 0L, 0L, 0L};
9542. return data;
9543. }
9544. public static final BitSet _tokenSet_70 = new BitSet(mk_tokenSet_70());
9545. private static final long[] mk_tokenSet_71() {
9546. long[] data = { -8070450533322321024L, 4501453380673077271L, 16128L, 0L, 0L, 0L};
9547. return data;
9548. }
9549. public static final BitSet _tokenSet_71 = new BitSet(mk_tokenSet_71());
9550. private static final long[] mk_tokenSet_72() {
9551. long[] data = { 9006650438451744L, 18014398509481984L, 0L, 0L};
9552. return data;
9553. }
9554. public static final BitSet _tokenSet_72 = new BitSet(mk_tokenSet_72());
9555. private static final long[] mk_tokenSet_73() {
9556. long[] data = { -8142508125748723200L, 18014398509482000L, 15872L, 0L, 0L, 0L};
9557. return data;
9558. }
9559. public static final BitSet _tokenSet_73 = new BitSet(mk_tokenSet_73());
9560. private static final long[] mk_tokenSet_74() {
9561. long[] data = { 137438953472L, 1008806316530991104L, 0L, 0L};
9562. return data;
9563. }
9564. public static final BitSet _tokenSet_74 = new BitSet(mk_tokenSet_74());
9565. private static final long[] mk_tokenSet_75() {
9566. long[] data = { 72057592963273600L, 18014398509481984L, 0L, 0L};
9567. return data;
9568. }
9569. public static final BitSet _tokenSet_75 = new BitSet(mk_tokenSet_75());
9570. private static final long[] mk_tokenSet_76() {
9571. long[] data = { 1152921504606576608L, -4591419820120997825L, 255L, 0L, 0L, 0L};
9572. return data;
9573. }
9574. public static final BitSet _tokenSet_76 = new BitSet(mk_tokenSet_76());
9575. private static final long[] mk_tokenSet_77() {
9576. long[] data = { 100663808L, -4593671619917905913L, 255L, 0L, 0L, 0L};
9577. return data;
9578. }
9579. public static final BitSet _tokenSet_77 = new BitSet(mk_tokenSet_77());
9580. private static final long[] mk_tokenSet_78() {
9581. long[] data = { -8133500993635759520L, -108086391073669057L, 16383L, 0L, 0L, 0L};
9582. return data;
9583. }
9584. public static final BitSet _tokenSet_78 = new BitSet(mk_tokenSet_78());
9585. private static final long[] mk_tokenSet_79() {
9586. long[] data = { 1611253856L, 2251799796908075L, 0L, 0L};
9587. return data;
9588. }
9589. public static final BitSet _tokenSet_79 = new BitSet(mk_tokenSet_79());
9590.
9591. }
| 1. // $ANTLR 2.7.7 (20060930): "CppParser4Java.g" -> "CPPParser.java"$
2.
3. /*REMOVE_BEGIN*/
4. package org.argouml.language.cpp.reveng;
5. /*REMOVE_END*/
6.
7. import java.util.Hashtable;
8. import java.util.List;
9. import java.util.ArrayList;
10.
11. import antlr.TokenBuffer;
12. import antlr.TokenStreamException;
13. import antlr.TokenStreamIOException;
14. import antlr.ANTLRException;
15. import antlr.LLkParser;
16. import antlr.Token;
17. import antlr.TokenStream;
18. import antlr.RecognitionException;
19. import antlr.NoViableAltException;
20. import antlr.MismatchedTokenException;
21. import antlr.SemanticException;
22. import antlr.ParserSharedInputState;
23. import antlr.collections.impl.BitSet;
24.
25. public class CPPParser extends antlr.LLkParser implements STDCTokenTypes
26. {
27.
28.
29. private Modeler m;
30.
31. String enclosingClass="";//name of current class
32. boolean _td=false; // is type declaration?
33. Hashtable symbols=new Hashtable();
34.
35.
36. public boolean qualifiedItemIsOneOf(java.util.BitSet qiFlags, int lookahead_offset) throws TokenSt... 37. {
38. java.util.BitSet qi = qualifiedItemIs(lookahead_offset);
39. java.util.BitSet aux=(java.util.BitSet) qi.clone();
40. aux.and(qiFlags);
41. return (!aux.isEmpty());
42. }
43.
44.
45. // This is an important function, but will be replaced with
46. // an enhanced predicate in the future, once predicates
47. // and/or predicate guards can contain loops.
48. //
49. // Scan past the ::T::B:: to see what lies beyond.
50. // Return QI_TYPE if the qualified item can pose as type name.
51. // Note that T::T is NOT a type; it is a constructor. Also,
52. // class T { ... T...} yields the enclosed T as a ctor. This
53. // is probably a type as I separate out the constructor defs/decls,
54. // I want it consistent with T::T.
55. //
56. // In the below examples, I use A,B,T and example types, and
57. // a,b as example ids.
58. // In the below examples, any A or B may be a
59. // qualified template, i.e., A<...>
60. //
61. // T::T outside of class T yields QI_CTOR.
62. // T<...>::T outside of class T yields QI_CTOR.
63. // T inside of class T {...} yields QI_CTOR.
64. // T, ::T, A::T outside of class T yields QI_TYPE.
65. // a, ::a, A::B::a yields qiId
66. // a::b yields QI_INVALID
67. // ::operator, operator, A::B::operator yield qiOPerator
68. // A::*, A::B::* yield QI_PTR_MEMBER
69. // ::*, * yields QI_INVALID
70. // ::~T, ~T, A::~T yield QI_DTOR
71. // ~a, ~A::a, A::~T::, ~T:: yield QI_INVALID
72. public java.util.BitSet qualifiedItemIs(int lookahead_offset) throws TokenStreamException
73. {
74. int value;
75. int k = lookahead_offset + 1;
76. int final_type_idx = 0;
77. boolean scope_found = false;
78. // Skip leading "::"
79. if (LT(k).getType() == SCOPE)
80. {
81. k++;
82. scope_found = true;
83. }
84. // Skip sequences of T:: or T<...>::
85. //printf("support.cpp qualifiedItemIs while reached k %d type %d isType %d, isClass %d, guessing %... 86. // k,LT(k)->getType(),isTypeName((LT(k)->getText()).data()),isClassName((LT(k)->getText()).data())... 87. while ((LT(k).getType() == ID) && (isTypeName(LT(k).getText())))
88. {// If this type is the same as the last type, then ctor
89. if ((final_type_idx != 0) && (LT(final_type_idx).getText().equals(LT(k).getText())))
90. {// Like T::T
91. // As an extra check, do not allow T::T::
92. if (LT(k+1).getType() == SCOPE)
93. { //printf("support.cpp qualifiedItemIs QI_INVALID returned\n");
94. return CPPvariables.QI_INVALID;
95. }
96. else
97. {//printf("support.cpp qualifiedItemIs QI_CTOR returned\n");
98. return CPPvariables.QI_CTOR;
99. }
100. }
101.
102. // Record this as the most recent type seen in the series
103. final_type_idx = k;
104.
105. //printf("support.cpp qualifiedItemIs if step reached final_type_idx %d\n",final_type_idx);
106.
107. // Skip this token
108. k++;
109.
110. // Skip over any template qualifiers <...>
111. // I believe that "T<..." cannot be anything valid but a template
112. if (LT(k).getType() == LESSTHAN)
113. {
114. value=skipTemplateQualifiers(k);
115. if (value==k)
116. {//printf("support.cpp qualifiedItemIs QI_INVALID(2) returned\n");
117. return CPPvariables.QI_INVALID;
118. }
119. else
120. k=value;
121. //printf("support.cpp qualifiedItemIs template skipped, k %d\n",k);
122. // k has been updated to token following <...>
123. }
124. if (LT(k).getType() == SCOPE)
125. // Skip the "::" and keep going
126. {
127. k++;
128. scope_found = true;
129. }
130. else
131. {// Series terminated -- last ID in the sequence was a type
132. // Return ctor if last type is in containing class
133. // We already checked for T::T inside loop
134. if ( enclosingClass.equals(LT(final_type_idx).getText()))
135. { // Like class T T()
136. //printf("support.cpp qualifiedItemIs QI_CTOR(2) returned\n");
137. return CPPvariables.QI_CTOR;
138. }
139. else
140. {//printf("support.cpp qualifiedItemIs QI_TYPE returned\n");
141. return CPPvariables.QI_TYPE;
142. }
143. }
144. }
145. // LT(k) is not an ID, or it is an ID but not a typename.
146. //printf("support.cpp qualifiedItemIs second switch reached\n");
147. switch (LT(k).getType())
148. {
149. case ID:
150. // ID but not a typename
151. // Do not allow id::
152. if (LT(k+1).getType() == SCOPE)
153. {
154. //printf("support.cpp qualifiedItemIs QI_INVALID(3) returned\n");
155. return CPPvariables.QI_INVALID;
156. }
157. if (enclosingClass.equals(LT(k).getText()))
158. { // Like class T T()
159. //printf("support.cpp qualifiedItemIs QI_CTOR(3) returned\n");
160. return CPPvariables.QI_CTOR;
161. }
162. else
163. {
164. if (scope_found)
165. // DW 25/10/03 Assume type if at least one SCOPE present (test12.i)
166. return CPPvariables.QI_TYPE;
167. else
168. //printf("support.cpp qualifiedItemIs QI_VAR returned\n");
169. return CPPvariables.QI_VAR; // DW 19/03/04 was QI_ID Could be function?
170. }
171. case TILDE:
172. // check for dtor
173. if ((LT(k+1).getType() == ID) && (isTypeName(LT(k+1).getText())) &&(LT(k+2).getType() != SCOPE))... 174. { // Like ~B or A::B::~B
175. // Also (incorrectly?) matches ::~A.
176. //printf("support.cpp qualifiedItemIs QI_DTOR returned\n");
177. return CPPvariables.QI_DTOR;
178. }
179. else
180. { // ~a or ~A::a is QI_INVALID
181. //printf("support.cpp qualifiedItemIs QI_INVALID(4) returned\n");
182. return CPPvariables.QI_INVALID;
183. }
184. case STAR:
185. // Like A::*
186. // Do not allow * or ::*
187. if (final_type_idx == 0)
188. { // Haven't seen a type yet
189. //printf("support.cpp qualifiedItemIs QI_INVALID(5) returned\n");
190. return CPPvariables.QI_INVALID;
191. }
192. else
193. { //printf("support.cpp qualifiedItemIs QI_PTR_MEMBER returned\n");
194. return CPPvariables.QI_PTR_MEMBER;
195. }
196. case OPERATOR:
197. // Like A::operator, ::operator, or operator
198. //printf("support.cpp qualifiedItemIs QI_OPERATOR returned\n");
199. return CPPvariables.QI_OPERATOR;
200. default:
201. // Something that neither starts with :: or ID, or
202. // a :: not followed by ID, operator, ~, or *
203. //printf("support.cpp qualifiedItemIs QI_INVALID(6) returned\n");
204. return CPPvariables.QI_INVALID;
205. }
206. }
207.
208. // Skip over <...>. This correctly handles nested <> and (), e.g:
209. // <T>
210. // < (i>3) >
211. // < T2<...> >
212. // but not
213. // < i>3 >
214. //
215. // On input, kInOut is the index of the "<"
216. // On output, if the return is true, then
217. // kInOut is the index of the token after ">"
218. // else
219. // kInOut is unchanged
220.
221. public int skipTemplateQualifiers(int kInOut) throws TokenStreamException
222. {
223. // Start after "<"
224. int k = kInOut + 1;
225. int value;
226. while (LT(k).getType() != GREATERTHAN) // scan to end of <...>
227. {
228. switch (LT(k).getType())
229. {
230. case EOF:
231. return kInOut;
232. case LESSTHAN:
233. value=skipTemplateQualifiers(k);
234. if (value==k)
235. {
236. return kInOut;
237. }
238. else
239. k=value;
240. break;
241. case LPAREN:
242. value=skipNestedParens(k);
243. if (value==k)
244. {
245. return kInOut;
246. }
247. else
248. k=value;
249. break;
250. default:
251. k++; // skip everything else
252. break;
253. }
254. if (k > CPPvariables.MAX_TEMPLATE_TOKEN_SCAN)
255. {
256. return kInOut;
257. }
258. }
259.
260. // Update output argument to point past ">"
261. kInOut = k + 1;
262. return kInOut;
263. }
264.
265. // Skip over (...). This correctly handles nested (), e.g:
266. // (i>3, (i>5))
267. //
268. // On input, kInOut is the index of the "("
269. // On output, if the return is true, then
270. // kInOut is the index of the token after ")"
271. // else
272. // kInOut is unchanged
273. public int skipNestedParens(int kInOut) throws TokenStreamException
274. {
275. // Start after "("
276. int k = kInOut + 1;
277. int value;
278. while (LT(k).getType() != RPAREN) // scan to end of (...)
279. {
280. switch (LT(k).getType())
281. {
282. case EOF:
283. return kInOut;
284. case LPAREN:
285. value=skipNestedParens(k);
286. if (value==k)
287. {
288. return kInOut;
289. }
290. else
291. k=value;
292. break;
293. default:
294. k++; // skip everything else
295. break;
296. }
297. if (k > CPPvariables.MAX_TEMPLATE_TOKEN_SCAN)
298. {
299. return kInOut;
300. }
301. }
302. // Update output argument to point past ")"
303. kInOut = k + 1;
304. return kInOut;
305. }
306.
307. // Return true if "::blah" or "fu::bar<args>::..." found.
308. public boolean scopedItem(int k) throws TokenStreamException
309. {
310. //printf("support.cpp scopedItem k %d\n",k);
311. return (LT(k).getType()==SCOPE ||
312. (LT(k).getType()==ID && !finalQualifier(k)));
313. }
314.
315. // Return true if ID<...> or ID is last item in qualified item list.
316. // Return false if LT(k) is not an ID.
317. // ID must be a type to check for ID<...>,
318. // or else we would get confused by "i<3"
319. public boolean finalQualifier(int k) throws TokenStreamException
320. {
321. if (LT(k).getType()==ID)
322. {
323. if ((isTypeName(LT(k).getText())) && (LT(k+1).getType()==LESSTHAN))
324. {
325. // Starts with "T<". Skip <...>
326. k++;
327. k=skipTemplateQualifiers(k);
328. }
329. else
330. {
331. // skip ID;
332. k++;
333. }
334. return (LT(k).getType() != SCOPE );
335. }
336. else
337. { // not an ID
338. return false;
339. }
340. }
341.
342. /*
343. * Return true if 's' can pose as a type name
344. */
345. public boolean isTypeName(String s)
346. {
347. String type="";
348. if (!symbols.containsKey(s))
349. {
350. //printf("support.cpp isTypeName %s not found\n",s);
351. return false;
352. }
353. else
354. type=(String) symbols.get(s);
355. if (type.equals(CPPvariables.OT_TYPE_DEF)||
356. type.equals(CPPvariables.OT_ENUM)||
357. type.equals(CPPvariables.OT_CLASS)||
358. type.equals(CPPvariables.OT_STRUCT)||
359. type.equals(CPPvariables.OT_UNION))
360. {
361. return true;
362. }
363. return false;
364. }
365.
366. public void declaratorID(String id, java.util.BitSet qi)
367. {
368. if ((qi.equals(CPPvariables.QI_TYPE)) || (_td)) // Check for type declaration
369. {
370. if (!symbols.containsKey(id))
371. symbols.put(id, CPPvariables.OT_TYPE_DEF);
372. }
373. }
374.
375. protected CPPParser(TokenBuffer tokenBuf, int k) {
376. super(tokenBuf,k);
377. tokenNames = _tokenNames;
378. }
379.
380. public CPPParser(TokenBuffer tokenBuf) {
381. this(tokenBuf,2);
382. }
383.
384. protected CPPParser(TokenStream lexer, int k) {
385. super(lexer,k);
386. tokenNames = _tokenNames;
387. }
388.
389. public CPPParser(TokenStream lexer) {
390. this(lexer,2);
391. }
392.
393. public CPPParser(ParserSharedInputState state) {
394. super(state,2);
395. tokenNames = _tokenNames;
396. }
397.
398. public final void translation_unit(
399. Modeler modeler
400. ) throws RecognitionException, TokenStreamException {
401.
402.
403. if(!symbols.containsKey("std"))
404. symbols.put("std",CPPvariables.OT_TYPE_DEF);
405. m = modeler;
406.
407.
408. if ( inputState.guessing==0 ) {
409. m.beginTranslationUnit();
410. }
411. {
412. int _cnt3=0;
413. _loop3:
414. do {
415. if ((_tokenSet_0.member(LA(1)))) {
416. external_declaration();
417. }
418. else {
419. if ( _cnt3>=1 ) { break _loop3; } else {throw new NoViableAltException(LT(1), getFilename());}
420. }
421.
422. _cnt3++;
423. } while (true);
424. }
425. match(Token.EOF_TYPE);
426. if ( inputState.guessing==0 ) {
427. m.endTranslationUnit();
428. }
429. }
430.
431. public final void external_declaration() throws RecognitionException, TokenStreamException {
432.
433. String s="";
434.
435. {
436. switch ( LA(1)) {
437. case LITERAL_namespace:
438. {
439. decl_namespace();
440. break;
441. }
442. case SEMICOLON:
443. {
444. match(SEMICOLON);
445. break;
446. }
447. default:
448. boolean synPredMatched7 = false;
449. if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
450. int _m7 = mark();
451. synPredMatched7 = true;
452. inputState.guessing++;
453. try {
454. {
455. match(LITERAL_template);
456. match(LESSTHAN);
457. match(GREATERTHAN);
458. }
459. }
460. catch (RecognitionException pe) {
461. synPredMatched7 = false;
462. }
463. rewind(_m7);
464. inputState.guessing--;
465. }
466. if ( synPredMatched7 ) {
467. match(LITERAL_template);
468. match(LESSTHAN);
469. match(GREATERTHAN);
470. declaration();
471. }
472. else {
473. boolean synPredMatched10 = false;
474. if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
475. int _m10 = mark();
476. synPredMatched10 = true;
477. inputState.guessing++;
478. try {
479. {
480. {
481. switch ( LA(1)) {
482. case LITERAL_typedef:
483. {
484. match(LITERAL_typedef);
485. break;
486. }
487. case LITERAL_class:
488. case LITERAL_struct:
489. case LITERAL_union:
490. {
491. break;
492. }
493. default:
494. {
495. throw new NoViableAltException(LT(1), getFilename());
496. }
497. }
498. }
499. class_head();
500. }
501. }
502. catch (RecognitionException pe) {
503. synPredMatched10 = false;
504. }
505. rewind(_m10);
506. inputState.guessing--;
507. }
508. if ( synPredMatched10 ) {
509. declaration();
510. }
511. else {
512. boolean synPredMatched12 = false;
513. if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
514. int _m12 = mark();
515. synPredMatched12 = true;
516. inputState.guessing++;
517. try {
518. {
519. template_head();
520. class_head();
521. }
522. }
523. catch (RecognitionException pe) {
524. synPredMatched12 = false;
525. }
526. rewind(_m12);
527. inputState.guessing--;
528. }
529. if ( synPredMatched12 ) {
530. template_head();
531. declaration();
532. }
533. else {
534. boolean synPredMatched15 = false;
535. if (((LA(1)==LITERAL_enum) && (LA(2)==ID||LA(2)==LCURLY))) {
536. int _m15 = mark();
537. synPredMatched15 = true;
538. inputState.guessing++;
539. try {
540. {
541. match(LITERAL_enum);
542. {
543. switch ( LA(1)) {
544. case ID:
545. {
546. match(ID);
547. break;
548. }
549. case LCURLY:
550. {
551. break;
552. }
553. default:
554. {
555. throw new NoViableAltException(LT(1), getFilename());
556. }
557. }
558. }
559. match(LCURLY);
560. }
561. }
562. catch (RecognitionException pe) {
563. synPredMatched15 = false;
564. }
565. rewind(_m15);
566. inputState.guessing--;
567. }
568. if ( synPredMatched15 ) {
569. enum_specifier();
570. {
571. switch ( LA(1)) {
572. case ID:
573. case LITERAL__stdcall:
574. case LITERAL___stdcall:
575. case LPAREN:
576. case OPERATOR:
577. case LITERAL_this:
578. case LITERAL_true:
579. case LITERAL_false:
580. case STAR:
581. case AMPERSAND:
582. case TILDE:
583. case SCOPE:
584. case LITERAL__cdecl:
585. case LITERAL___cdecl:
586. case LITERAL__near:
587. case LITERAL___near:
588. case LITERAL__far:
589. case LITERAL___far:
590. case LITERAL___interrupt:
591. case LITERAL_pascal:
592. case LITERAL__pascal:
593. case LITERAL___pascal:
594. {
595. init_declarator_list();
596. break;
597. }
598. case SEMICOLON:
599. {
600. break;
601. }
602. default:
603. {
604. throw new NoViableAltException(LT(1), getFilename());
605. }
606. }
607. }
608. match(SEMICOLON);
609. }
610. else {
611. boolean synPredMatched19 = false;
612. if (((_tokenSet_3.member(LA(1))) && (_tokenSet_4.member(LA(2))))) {
613. int _m19 = mark();
614. synPredMatched19 = true;
615. inputState.guessing++;
616. try {
617. {
618. {
619. switch ( LA(1)) {
620. case LITERAL_template:
621. {
622. template_head();
623. break;
624. }
625. case ID:
626. case LITERAL_inline:
627. case LITERAL__inline:
628. case LITERAL___inline:
629. case LITERAL_virtual:
630. case TILDE:
631. case SCOPE:
632. {
633. break;
634. }
635. default:
636. {
637. throw new NoViableAltException(LT(1), getFilename());
638. }
639. }
640. }
641. dtor_head();
642. match(LCURLY);
643. }
644. }
645. catch (RecognitionException pe) {
646. synPredMatched19 = false;
647. }
648. rewind(_m19);
649. inputState.guessing--;
650. }
651. if ( synPredMatched19 ) {
652. {
653. switch ( LA(1)) {
654. case LITERAL_template:
655. {
656. template_head();
657. break;
658. }
659. case ID:
660. case LITERAL_inline:
661. case LITERAL__inline:
662. case LITERAL___inline:
663. case LITERAL_virtual:
664. case TILDE:
665. case SCOPE:
666. {
667. break;
668. }
669. default:
670. {
671. throw new NoViableAltException(LT(1), getFilename());
672. }
673. }
674. }
675. dtor_head();
676. dtor_body();
677. }
678. else {
679. boolean synPredMatched23 = false;
680. if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
681. int _m23 = mark();
682. synPredMatched23 = true;
683. inputState.guessing++;
684. try {
685. {
686. {
687. if ((true) && (true)) {
688. ctor_decl_spec();
689. }
690. else {
691. }
692.
693. }
694. if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
695. throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
696. }
697. }
698. catch (RecognitionException pe) {
699. synPredMatched23 = false;
700. }
701. rewind(_m23);
702. inputState.guessing--;
703. }
704. if ( synPredMatched23 ) {
705. ctor_definition();
706. }
707. else {
708. boolean synPredMatched26 = false;
709. if (((_tokenSet_7.member(LA(1))) && (_tokenSet_8.member(LA(2))))) {
710. int _m26 = mark();
711. synPredMatched26 = true;
712. inputState.guessing++;
713. try {
714. {
715. {
716. switch ( LA(1)) {
717. case LITERAL_inline:
718. {
719. match(LITERAL_inline);
720. break;
721. }
722. case ID:
723. case OPERATOR:
724. case SCOPE:
725. {
726. break;
727. }
728. default:
729. {
730. throw new NoViableAltException(LT(1), getFilename());
731. }
732. }
733. }
734. scope_override();
735. conversion_function_decl_or_def();
736. }
737. }
738. catch (RecognitionException pe) {
739. synPredMatched26 = false;
740. }
741. rewind(_m26);
742. inputState.guessing--;
743. }
744. if ( synPredMatched26 ) {
745. {
746. switch ( LA(1)) {
747. case LITERAL_inline:
748. {
749. match(LITERAL_inline);
750. break;
751. }
752. case ID:
753. case OPERATOR:
754. case SCOPE:
755. {
756. break;
757. }
758. default:
759. {
760. throw new NoViableAltException(LT(1), getFilename());
761. }
762. }
763. }
764. s=scope_override();
765. conversion_function_decl_or_def();
766. }
767. else {
768. boolean synPredMatched29 = false;
769. if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
770. int _m29 = mark();
771. synPredMatched29 = true;
772. inputState.guessing++;
773. try {
774. {
775. declaration_specifiers();
776. function_declarator();
777. match(SEMICOLON);
778. }
779. }
780. catch (RecognitionException pe) {
781. synPredMatched29 = false;
782. }
783. rewind(_m29);
784. inputState.guessing--;
785. }
786. if ( synPredMatched29 ) {
787. declaration();
788. }
789. else {
790. boolean synPredMatched31 = false;
791. if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
792. int _m31 = mark();
793. synPredMatched31 = true;
794. inputState.guessing++;
795. try {
796. {
797. declaration_specifiers();
798. function_declarator();
799. match(LCURLY);
800. }
801. }
802. catch (RecognitionException pe) {
803. synPredMatched31 = false;
804. }
805. rewind(_m31);
806. inputState.guessing--;
807. }
808. if ( synPredMatched31 ) {
809. if ( inputState.guessing==0 ) {
810. m.beginFunctionDefinition();
811. }
812. function_definition();
813. if ( inputState.guessing==0 ) {
814. m.endFunctionDefinition();
815. }
816. }
817. else {
818. boolean synPredMatched33 = false;
819. if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
820. int _m33 = mark();
821. synPredMatched33 = true;
822. inputState.guessing++;
823. try {
824. {
825. declaration_specifiers();
826. function_declarator();
827. declaration();
828. }
829. }
830. catch (RecognitionException pe) {
831. synPredMatched33 = false;
832. }
833. rewind(_m33);
834. inputState.guessing--;
835. }
836. if ( synPredMatched33 ) {
837. function_definition();
838. }
839. else {
840. boolean synPredMatched36 = false;
841. if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
842. int _m36 = mark();
843. synPredMatched36 = true;
844. inputState.guessing++;
845. try {
846. {
847. template_head();
848. declaration_specifiers();
849. {
850. switch ( LA(1)) {
851. case ID:
852. case LITERAL__stdcall:
853. case LITERAL___stdcall:
854. case LPAREN:
855. case OPERATOR:
856. case LITERAL_this:
857. case LITERAL_true:
858. case LITERAL_false:
859. case STAR:
860. case AMPERSAND:
861. case TILDE:
862. case SCOPE:
863. case LITERAL__cdecl:
864. case LITERAL___cdecl:
865. case LITERAL__near:
866. case LITERAL___near:
867. case LITERAL__far:
868. case LITERAL___far:
869. case LITERAL___interrupt:
870. case LITERAL_pascal:
871. case LITERAL__pascal:
872. case LITERAL___pascal:
873. {
874. init_declarator_list();
875. break;
876. }
877. case SEMICOLON:
878. {
879. break;
880. }
881. default:
882. {
883. throw new NoViableAltException(LT(1), getFilename());
884. }
885. }
886. }
887. match(SEMICOLON);
888. }
889. }
890. catch (RecognitionException pe) {
891. synPredMatched36 = false;
892. }
893. rewind(_m36);
894. inputState.guessing--;
895. }
896. if ( synPredMatched36 ) {
897. template_head();
898. declaration_specifiers();
899. {
900. switch ( LA(1)) {
901. case ID:
902. case LITERAL__stdcall:
903. case LITERAL___stdcall:
904. case LPAREN:
905. case OPERATOR:
906. case LITERAL_this:
907. case LITERAL_true:
908. case LITERAL_false:
909. case STAR:
910. case AMPERSAND:
911. case TILDE:
912. case SCOPE:
913. case LITERAL__cdecl:
914. case LITERAL___cdecl:
915. case LITERAL__near:
916. case LITERAL___near:
917. case LITERAL__far:
918. case LITERAL___far:
919. case LITERAL___interrupt:
920. case LITERAL_pascal:
921. case LITERAL__pascal:
922. case LITERAL___pascal:
923. {
924. init_declarator_list();
925. break;
926. }
927. case SEMICOLON:
928. {
929. break;
930. }
931. default:
932. {
933. throw new NoViableAltException(LT(1), getFilename());
934. }
935. }
936. }
937. match(SEMICOLON);
938. }
939. else if ((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN)) {
940. template_head();
941. {
942. boolean synPredMatched40 = false;
943. if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
944. int _m40 = mark();
945. synPredMatched40 = true;
946. inputState.guessing++;
947. try {
948. {
949. ctor_decl_spec();
950. if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
951. throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
952. }
953. }
954. catch (RecognitionException pe) {
955. synPredMatched40 = false;
956. }
957. rewind(_m40);
958. inputState.guessing--;
959. }
960. if ( synPredMatched40 ) {
961. ctor_definition();
962. }
963. else {
964. boolean synPredMatched42 = false;
965. if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
966. int _m42 = mark();
967. synPredMatched42 = true;
968. inputState.guessing++;
969. try {
970. {
971. declaration_specifiers();
972. function_declarator();
973. match(SEMICOLON);
974. }
975. }
976. catch (RecognitionException pe) {
977. synPredMatched42 = false;
978. }
979. rewind(_m42);
980. inputState.guessing--;
981. }
982. if ( synPredMatched42 ) {
983. declaration();
984. }
985. else {
986. boolean synPredMatched44 = false;
987. if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
988. int _m44 = mark();
989. synPredMatched44 = true;
990. inputState.guessing++;
991. try {
992. {
993. declaration_specifiers();
994. function_declarator();
995. match(LCURLY);
996. }
997. }
998. catch (RecognitionException pe) {
999. synPredMatched44 = false;
1000. }
1001. rewind(_m44);
1002. inputState.guessing--;
1003. }
1004. if ( synPredMatched44 ) {
1005. function_definition();
1006. }
1007. else {
1008. throw new NoViableAltException(LT(1), getFilename());
1009. }
1010. }}
1011. }
1012. }
1013. else if ((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2)))) {
1014. declaration();
1015. }
1016. else {
1017. throw new NoViableAltException(LT(1), getFilename());
1018. }
1019. }}}}}}}}}}}
1020. }
1021. }
1022.
1023. public final void declaration() throws RecognitionException, TokenStreamException {
1024.
1025.
1026. boolean synPredMatched106 = false;
1027. if (((LA(1)==LITERAL_extern) && (LA(2)==StringLiteral))) {
1028. int _m106 = mark();
1029. synPredMatched106 = true;
1030. inputState.guessing++;
1031. try {
1032. {
1033. match(LITERAL_extern);
1034. match(StringLiteral);
1035. }
1036. }
1037. catch (RecognitionException pe) {
1038. synPredMatched106 = false;
1039. }
1040. rewind(_m106);
1041. inputState.guessing--;
1042. }
1043. if ( synPredMatched106 ) {
1044. linkage_specification();
1045. }
1046. else if ((_tokenSet_11.member(LA(1))) && (_tokenSet_12.member(LA(2)))) {
1047. declaration_specifiers();
1048. {
1049. switch ( LA(1)) {
1050. case ID:
1051. case COMMA:
1052. case LITERAL__stdcall:
1053. case LITERAL___stdcall:
1054. case LPAREN:
1055. case OPERATOR:
1056. case LITERAL_this:
1057. case LITERAL_true:
1058. case LITERAL_false:
1059. case STAR:
1060. case AMPERSAND:
1061. case TILDE:
1062. case SCOPE:
1063. case LITERAL__cdecl:
1064. case LITERAL___cdecl:
1065. case LITERAL__near:
1066. case LITERAL___near:
1067. case LITERAL__far:
1068. case LITERAL___far:
1069. case LITERAL___interrupt:
1070. case LITERAL_pascal:
1071. case LITERAL__pascal:
1072. case LITERAL___pascal:
1073. {
1074. {
1075. switch ( LA(1)) {
1076. case COMMA:
1077. {
1078. match(COMMA);
1079. break;
1080. }
1081. case ID:
1082. case LITERAL__stdcall:
1083. case LITERAL___stdcall:
1084. case LPAREN:
1085. case OPERATOR:
1086. case LITERAL_this:
1087. case LITERAL_true:
1088. case LITERAL_false:
1089. case STAR:
1090. case AMPERSAND:
1091. case TILDE:
1092. case SCOPE:
1093. case LITERAL__cdecl:
1094. case LITERAL___cdecl:
1095. case LITERAL__near:
1096. case LITERAL___near:
1097. case LITERAL__far:
1098. case LITERAL___far:
1099. case LITERAL___interrupt:
1100. case LITERAL_pascal:
1101. case LITERAL__pascal:
1102. case LITERAL___pascal:
1103. {
1104. break;
1105. }
1106. default:
1107. {
1108. throw new NoViableAltException(LT(1), getFilename());
1109. }
1110. }
1111. }
1112. init_declarator_list();
1113. break;
1114. }
1115. case SEMICOLON:
1116. {
1117. break;
1118. }
1119. default:
1120. {
1121. throw new NoViableAltException(LT(1), getFilename());
1122. }
1123. }
1124. }
1125. match(SEMICOLON);
1126. }
1127. else if ((LA(1)==LITERAL_using)) {
1128. using_declaration();
1129. }
1130. else {
1131. throw new NoViableAltException(LT(1), getFilename());
1132. }
1133.
1134. }
1135.
1136. public final void class_head() throws RecognitionException, TokenStreamException {
1137.
1138.
1139. {
1140. switch ( LA(1)) {
1141. case LITERAL_struct:
1142. {
1143. match(LITERAL_struct);
1144. break;
1145. }
1146. case LITERAL_union:
1147. {
1148. match(LITERAL_union);
1149. break;
1150. }
1151. case LITERAL_class:
1152. {
1153. match(LITERAL_class);
1154. break;
1155. }
1156. default:
1157. {
1158. throw new NoViableAltException(LT(1), getFilename());
1159. }
1160. }
1161. }
1162. {
1163. switch ( LA(1)) {
1164. case ID:
1165. {
1166. match(ID);
1167. {
1168. switch ( LA(1)) {
1169. case LESSTHAN:
1170. {
1171. match(LESSTHAN);
1172. template_argument_list();
1173. match(GREATERTHAN);
1174. break;
1175. }
1176. case LCURLY:
1177. case COLON:
1178. {
1179. break;
1180. }
1181. default:
1182. {
1183. throw new NoViableAltException(LT(1), getFilename());
1184. }
1185. }
1186. }
1187. {
1188. switch ( LA(1)) {
1189. case COLON:
1190. {
1191. base_clause();
1192. break;
1193. }
1194. case LCURLY:
1195. {
1196. break;
1197. }
1198. default:
1199. {
1200. throw new NoViableAltException(LT(1), getFilename());
1201. }
1202. }
1203. }
1204. break;
1205. }
1206. case LCURLY:
1207. {
1208. break;
1209. }
1210. default:
1211. {
1212. throw new NoViableAltException(LT(1), getFilename());
1213. }
1214. }
1215. }
1216. match(LCURLY);
1217. }
1218.
1219. public final void template_head() throws RecognitionException, TokenStreamException {
1220.
1221.
1222. match(LITERAL_template);
1223. match(LESSTHAN);
1224. template_parameter_list();
1225. match(GREATERTHAN);
1226. }
1227.
1228. public final void enum_specifier() throws RecognitionException, TokenStreamException {
1229.
1230. Token id = null;
1231.
1232. match(LITERAL_enum);
1233. {
1234. switch ( LA(1)) {
1235. case LCURLY:
1236. {
1237. match(LCURLY);
1238. enumerator_list();
1239. match(RCURLY);
1240. break;
1241. }
1242. case ID:
1243. {
1244. id = LT(1);
1245. match(ID);
1246. if ( inputState.guessing==0 ) {
1247. if(!symbols.containsKey(id.getText()))
1248. symbols.put(id.getText(),CPPvariables.OT_ENUM);
1249.
1250. }
1251. {
1252. switch ( LA(1)) {
1253. case LCURLY:
1254. {
1255. match(LCURLY);
1256. enumerator_list();
1257. match(RCURLY);
1258. break;
1259. }
1260. case LESSTHAN:
1261. case GREATERTHAN:
1262. case ID:
1263. case SEMICOLON:
1264. case RCURLY:
1265. case ASSIGNEQUAL:
1266. case COLON:
1267. case COMMA:
1268. case LITERAL__stdcall:
1269. case LITERAL___stdcall:
1270. case LPAREN:
1271. case RPAREN:
1272. case OPERATOR:
1273. case LITERAL_this:
1274. case LITERAL_true:
1275. case LITERAL_false:
1276. case STAR:
1277. case AMPERSAND:
1278. case LSQUARE:
1279. case RSQUARE:
1280. case TILDE:
1281. case ELLIPSIS:
1282. case TIMESEQUAL:
1283. case DIVIDEEQUAL:
1284. case MINUSEQUAL:
1285. case PLUSEQUAL:
1286. case MODEQUAL:
1287. case SHIFTLEFTEQUAL:
1288. case SHIFTRIGHTEQUAL:
1289. case BITWISEANDEQUAL:
1290. case BITWISEXOREQUAL:
1291. case BITWISEOREQUAL:
1292. case QUESTIONMARK:
1293. case OR:
1294. case AND:
1295. case BITWISEOR:
1296. case BITWISEXOR:
1297. case NOTEQUAL:
1298. case EQUAL:
1299. case LESSTHANOREQUALTO:
1300. case GREATERTHANOREQUALTO:
1301. case SHIFTLEFT:
1302. case SHIFTRIGHT:
1303. case PLUS:
1304. case MINUS:
1305. case DIVIDE:
1306. case MOD:
1307. case DOTMBR:
1308. case POINTERTOMBR:
1309. case SCOPE:
1310. case LITERAL__cdecl:
1311. case LITERAL___cdecl:
1312. case LITERAL__near:
1313. case LITERAL___near:
1314. case LITERAL__far:
1315. case LITERAL___far:
1316. case LITERAL___interrupt:
1317. case LITERAL_pascal:
1318. case LITERAL__pascal:
1319. case LITERAL___pascal:
1320. {
1321. break;
1322. }
1323. default:
1324. {
1325. throw new NoViableAltException(LT(1), getFilename());
1326. }
1327. }
1328. }
1329. break;
1330. }
1331. default:
1332. {
1333. throw new NoViableAltException(LT(1), getFilename());
1334. }
1335. }
1336. }
1337. }
1338.
1339. public final void init_declarator_list() throws RecognitionException, TokenStreamException {
1340.
1341.
1342. init_declarator();
1343. {
1344. _loop156:
1345. do {
1346. if ((LA(1)==COMMA)) {
1347. match(COMMA);
1348. init_declarator();
1349. }
1350. else {
1351. break _loop156;
1352. }
1353.
1354. } while (true);
1355. }
1356. }
1357.
1358. public final void dtor_head() throws RecognitionException, TokenStreamException {
1359.
1360.
1361. if ( inputState.guessing==0 ) {
1362. m.beginDtorHead();
1363. }
1364. dtor_decl_spec();
1365. dtor_declarator();
1366. if ( inputState.guessing==0 ) {
1367. m.endDtorHead();
1368. }
1369. }
1370.
1371. public final void dtor_body() throws RecognitionException, TokenStreamException {
1372.
1373.
1374. compound_statement();
1375. }
1376.
1377. public final void ctor_decl_spec() throws RecognitionException, TokenStreamException {
1378.
1379. List declSpecs = new ArrayList();
1380.
1381. {
1382. _loop240:
1383. do {
1384. switch ( LA(1)) {
1385. case LITERAL_inline:
1386. case LITERAL__inline:
1387. case LITERAL___inline:
1388. {
1389. {
1390. switch ( LA(1)) {
1391. case LITERAL_inline:
1392. {
1393. match(LITERAL_inline);
1394. break;
1395. }
1396. case LITERAL__inline:
1397. {
1398. match(LITERAL__inline);
1399. break;
1400. }
1401. case LITERAL___inline:
1402. {
1403. match(LITERAL___inline);
1404. break;
1405. }
1406. default:
1407. {
1408. throw new NoViableAltException(LT(1), getFilename());
1409. }
1410. }
1411. }
1412. if ( inputState.guessing==0 ) {
1413. declSpecs.add("inline");
1414. }
1415. break;
1416. }
1417. case LITERAL_explicit:
1418. {
1419. match(LITERAL_explicit);
1420. if ( inputState.guessing==0 ) {
1421. declSpecs.add("explicit");
1422. }
1423. break;
1424. }
1425. default:
1426. {
1427. break _loop240;
1428. }
1429. }
1430. } while (true);
1431. }
1432. if ( inputState.guessing==0 ) {
1433. m.declarationSpecifiers(declSpecs);
1434. }
1435. }
1436.
1437. public final void ctor_definition() throws RecognitionException, TokenStreamException {
1438.
1439.
1440. if ( inputState.guessing==0 ) {
1441. m.beginCtorDefinition();
1442. }
1443. ctor_head();
1444. ctor_body();
1445. if ( inputState.guessing==0 ) {
1446. m.endCtorDefinition();
1447. }
1448. }
1449.
1450. public final String scope_override() throws RecognitionException, TokenStreamException {
1451. String s="";
1452.
1453. Token id = null;
1454.
1455. String sitem="";
1456.
1457.
1458. {
1459. switch ( LA(1)) {
1460. case SCOPE:
1461. {
1462. match(SCOPE);
1463. if ( inputState.guessing==0 ) {
1464. sitem=sitem+"::";
1465. }
1466. break;
1467. }
1468. case ID:
1469. case OPERATOR:
1470. case LITERAL_this:
1471. case LITERAL_true:
1472. case LITERAL_false:
1473. case STAR:
1474. case TILDE:
1475. {
1476. break;
1477. }
1478. default:
1479. {
1480. throw new NoViableAltException(LT(1), getFilename());
1481. }
1482. }
1483. }
1484. {
1485. _loop457:
1486. do {
1487. if (((LA(1)==ID) && (LA(2)==LESSTHAN||LA(2)==SCOPE))&&(scopedItem(1))) {
1488. id = LT(1);
1489. match(ID);
1490. {
1491. switch ( LA(1)) {
1492. case LESSTHAN:
1493. {
1494. match(LESSTHAN);
1495. template_argument_list();
1496. match(GREATERTHAN);
1497. break;
1498. }
1499. case SCOPE:
1500. {
1501. break;
1502. }
1503. default:
1504. {
1505. throw new NoViableAltException(LT(1), getFilename());
1506. }
1507. }
1508. }
1509. match(SCOPE);
1510. if ( inputState.guessing==0 ) {
1511.
1512. sitem=sitem+id.getText();
1513. sitem=sitem+"::";
1514.
1515. }
1516. }
1517. else {
1518. break _loop457;
1519. }
1520.
1521. } while (true);
1522. }
1523. if ( inputState.guessing==0 ) {
1524. s = sitem;
1525. }
1526. return s;
1527. }
1528.
1529. public final void conversion_function_decl_or_def() throws RecognitionException, TokenStreamExcepti...1530.
1531.
1532. match(OPERATOR);
1533. declaration_specifiers();
1534. {
1535. switch ( LA(1)) {
1536. case STAR:
1537. {
1538. match(STAR);
1539. break;
1540. }
1541. case AMPERSAND:
1542. {
1543. match(AMPERSAND);
1544. break;
1545. }
1546. case LESSTHAN:
1547. case LPAREN:
1548. {
1549. break;
1550. }
1551. default:
1552. {
1553. throw new NoViableAltException(LT(1), getFilename());
1554. }
1555. }
1556. }
1557. {
1558. switch ( LA(1)) {
1559. case LESSTHAN:
1560. {
1561. match(LESSTHAN);
1562. template_parameter_list();
1563. match(GREATERTHAN);
1564. break;
1565. }
1566. case LPAREN:
1567. {
1568. break;
1569. }
1570. default:
1571. {
1572. throw new NoViableAltException(LT(1), getFilename());
1573. }
1574. }
1575. }
1576. match(LPAREN);
1577. {
1578. switch ( LA(1)) {
1579. case LITERAL_typedef:
1580. case LITERAL_enum:
1581. case ID:
1582. case LITERAL_inline:
1583. case LITERAL_extern:
1584. case LITERAL__inline:
1585. case LITERAL___inline:
1586. case LITERAL_virtual:
1587. case LITERAL_explicit:
1588. case LITERAL_friend:
1589. case LITERAL__stdcall:
1590. case LITERAL___stdcall:
1591. case LITERAL__declspec:
1592. case LITERAL___declspec:
1593. case LPAREN:
1594. case LITERAL_typename:
1595. case LITERAL_auto:
1596. case LITERAL_register:
1597. case LITERAL_static:
1598. case LITERAL_mutable:
1599. case LITERAL_const:
1600. case LITERAL_const_cast:
1601. case LITERAL_volatile:
1602. case LITERAL_char:
1603. case LITERAL_wchar_t:
1604. case LITERAL_bool:
1605. case LITERAL_short:
1606. case LITERAL_int:
1607. case 44:
1608. case 45:
1609. case 46:
1610. case LITERAL_long:
1611. case LITERAL_signed:
1612. case LITERAL_unsigned:
1613. case LITERAL_float:
1614. case LITERAL_double:
1615. case LITERAL_void:
1616. case LITERAL_class:
1617. case LITERAL_struct:
1618. case LITERAL_union:
1619. case OPERATOR:
1620. case LITERAL_this:
1621. case LITERAL_true:
1622. case LITERAL_false:
1623. case STAR:
1624. case AMPERSAND:
1625. case TILDE:
1626. case ELLIPSIS:
1627. case SCOPE:
1628. case LITERAL__cdecl:
1629. case LITERAL___cdecl:
1630. case LITERAL__near:
1631. case LITERAL___near:
1632. case LITERAL__far:
1633. case LITERAL___far:
1634. case LITERAL___interrupt:
1635. case LITERAL_pascal:
1636. case LITERAL__pascal:
1637. case LITERAL___pascal:
1638. {
1639. parameter_list();
1640. break;
1641. }
1642. case RPAREN:
1643. {
1644. break;
1645. }
1646. default:
1647. {
1648. throw new NoViableAltException(LT(1), getFilename());
1649. }
1650. }
1651. }
1652. match(RPAREN);
1653. {
1654. switch ( LA(1)) {
1655. case LITERAL_const:
1656. case LITERAL_const_cast:
1657. case LITERAL_volatile:
1658. {
1659. type_qualifier();
1660. break;
1661. }
1662. case LCURLY:
1663. case SEMICOLON:
1664. case LITERAL_throw:
1665. {
1666. break;
1667. }
1668. default:
1669. {
1670. throw new NoViableAltException(LT(1), getFilename());
1671. }
1672. }
1673. }
1674. {
1675. switch ( LA(1)) {
1676. case LITERAL_throw:
1677. {
1678. exception_specification();
1679. break;
1680. }
1681. case LCURLY:
1682. case SEMICOLON:
1683. {
1684. break;
1685. }
1686. default:
1687. {
1688. throw new NoViableAltException(LT(1), getFilename());
1689. }
1690. }
1691. }
1692. {
1693. switch ( LA(1)) {
1694. case LCURLY:
1695. {
1696. compound_statement();
1697. break;
1698. }
1699. case SEMICOLON:
1700. {
1701. match(SEMICOLON);
1702. break;
1703. }
1704. default:
1705. {
1706. throw new NoViableAltException(LT(1), getFilename());
1707. }
1708. }
1709. }
1710. }
1711.
1712. public final void declaration_specifiers() throws RecognitionException, TokenStreamException {
1713.
1714. _td=false; boolean td=false; List declSpecs = new ArrayList();
1715.
1716. {
1717. switch ( LA(1)) {
1718. case LITERAL_typedef:
1719. case LITERAL_enum:
1720. case ID:
1721. case LITERAL_inline:
1722. case LITERAL_extern:
1723. case LITERAL__inline:
1724. case LITERAL___inline:
1725. case LITERAL_virtual:
1726. case LITERAL_explicit:
1727. case LITERAL_friend:
1728. case LITERAL__stdcall:
1729. case LITERAL___stdcall:
1730. case LITERAL__declspec:
1731. case LITERAL___declspec:
1732. case LITERAL_auto:
1733. case LITERAL_register:
1734. case LITERAL_static:
1735. case LITERAL_mutable:
1736. case LITERAL_const:
1737. case LITERAL_const_cast:
1738. case LITERAL_volatile:
1739. case LITERAL_char:
1740. case LITERAL_wchar_t:
1741. case LITERAL_bool:
1742. case LITERAL_short:
1743. case LITERAL_int:
1744. case 44:
1745. case 45:
1746. case 46:
1747. case LITERAL_long:
1748. case LITERAL_signed:
1749. case LITERAL_unsigned:
1750. case LITERAL_float:
1751. case LITERAL_double:
1752. case LITERAL_void:
1753. case LITERAL_class:
1754. case LITERAL_struct:
1755. case LITERAL_union:
1756. case SCOPE:
1757. {
1758. {
1759. _loop119:
1760. do {
1761. switch ( LA(1)) {
1762. case LITERAL_extern:
1763. case LITERAL_auto:
1764. case LITERAL_register:
1765. case LITERAL_static:
1766. case LITERAL_mutable:
1767. {
1768. storage_class_specifier();
1769. break;
1770. }
1771. case LITERAL_const:
1772. case LITERAL_const_cast:
1773. case LITERAL_volatile:
1774. {
1775. type_qualifier();
1776. break;
1777. }
1778. case LITERAL_inline:
1779. case LITERAL__inline:
1780. case LITERAL___inline:
1781. {
1782. {
1783. switch ( LA(1)) {
1784. case LITERAL_inline:
1785. {
1786. match(LITERAL_inline);
1787. break;
1788. }
1789. case LITERAL__inline:
1790. {
1791. match(LITERAL__inline);
1792. break;
1793. }
1794. case LITERAL___inline:
1795. {
1796. match(LITERAL___inline);
1797. break;
1798. }
1799. default:
1800. {
1801. throw new NoViableAltException(LT(1), getFilename());
1802. }
1803. }
1804. }
1805. if ( inputState.guessing==0 ) {
1806. declSpecs.add("inline");
1807. }
1808. break;
1809. }
1810. case LITERAL_virtual:
1811. {
1812. match(LITERAL_virtual);
1813. if ( inputState.guessing==0 ) {
1814. declSpecs.add("virtual");
1815. }
1816. break;
1817. }
1818. case LITERAL_explicit:
1819. {
1820. match(LITERAL_explicit);
1821. if ( inputState.guessing==0 ) {
1822. declSpecs.add("explicit");
1823. }
1824. break;
1825. }
1826. case LITERAL_typedef:
1827. {
1828. match(LITERAL_typedef);
1829. if ( inputState.guessing==0 ) {
1830. td=true; declSpecs.add("typedef");
1831. }
1832. break;
1833. }
1834. case LITERAL_friend:
1835. {
1836. match(LITERAL_friend);
1837. if ( inputState.guessing==0 ) {
1838. declSpecs.add("friend");
1839. }
1840. break;
1841. }
1842. case LITERAL__stdcall:
1843. case LITERAL___stdcall:
1844. {
1845. {
1846. switch ( LA(1)) {
1847. case LITERAL__stdcall:
1848. {
1849. match(LITERAL__stdcall);
1850. break;
1851. }
1852. case LITERAL___stdcall:
1853. {
1854. match(LITERAL___stdcall);
1855. break;
1856. }
1857. default:
1858. {
1859. throw new NoViableAltException(LT(1), getFilename());
1860. }
1861. }
1862. }
1863. if ( inputState.guessing==0 ) {
1864. declSpecs.add("__stdcall");
1865. }
1866. break;
1867. }
1868. default:
1869. if ((LA(1)==LITERAL__declspec||LA(1)==LITERAL___declspec) && (LA(2)==LPAREN)) {
1870. {
1871. switch ( LA(1)) {
1872. case LITERAL__declspec:
1873. {
1874. match(LITERAL__declspec);
1875. break;
1876. }
1877. case LITERAL___declspec:
1878. {
1879. match(LITERAL___declspec);
1880. break;
1881. }
1882. default:
1883. {
1884. throw new NoViableAltException(LT(1), getFilename());
1885. }
1886. }
1887. }
1888. match(LPAREN);
1889. match(ID);
1890. match(RPAREN);
1891. }
1892. else {
1893. break _loop119;
1894. }
1895. }
1896. } while (true);
1897. }
1898. if ( inputState.guessing==0 ) {
1899. if (!declSpecs.isEmpty()) m.declarationSpecifiers(declSpecs);
1900. }
1901. type_specifier();
1902. break;
1903. }
1904. case LITERAL_typename:
1905. {
1906. match(LITERAL_typename);
1907. if ( inputState.guessing==0 ) {
1908. td=true;
1909. }
1910. direct_declarator();
1911. break;
1912. }
1913. default:
1914. {
1915. throw new NoViableAltException(LT(1), getFilename());
1916. }
1917. }
1918. }
1919. if ( inputState.guessing==0 ) {
1920. _td=td;
1921. }
1922. }
1923.
1924. public final void function_declarator() throws RecognitionException, TokenStreamException {
1925.
1926.
1927. boolean synPredMatched227 = false;
1928. if (((_tokenSet_13.member(LA(1))) && (_tokenSet_14.member(LA(2))))) {
1929. int _m227 = mark();
1930. synPredMatched227 = true;
1931. inputState.guessing++;
1932. try {
1933. {
1934. ptr_operator();
1935. }
1936. }
1937. catch (RecognitionException pe) {
1938. synPredMatched227 = false;
1939. }
1940. rewind(_m227);
1941. inputState.guessing--;
1942. }
1943. if ( synPredMatched227 ) {
1944. ptr_operator();
1945. function_declarator();
1946. }
1947. else if ((_tokenSet_15.member(LA(1))) && (_tokenSet_16.member(LA(2)))) {
1948. function_direct_declarator();
1949. }
1950. else {
1951. throw new NoViableAltException(LT(1), getFilename());
1952. }
1953.
1954. }
1955.
1956. public final void function_definition() throws RecognitionException, TokenStreamException {
1957.
1958. java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone(); auxBitSet.or(CPPvariabl...1959.
1960. {
1961. if (((_tokenSet_11.member(LA(1))) && (_tokenSet_17.member(LA(2))))&&(( !(LA(1)==SCOPE||LA(1)==ID) ...1962. declaration_specifiers();
1963. function_declarator();
1964. {
1965. if ((_tokenSet_18.member(LA(1))) && (_tokenSet_19.member(LA(2)))) {
1966. {
1967. _loop100:
1968. do {
1969. if ((_tokenSet_1.member(LA(1)))) {
1970. declaration();
1971. }
1972. else {
1973. break _loop100;
1974. }
1975.
1976. } while (true);
1977. }
1978. }
1979. else if ((LA(1)==LCURLY) && (_tokenSet_20.member(LA(2)))) {
1980. }
1981. else {
1982. throw new NoViableAltException(LT(1), getFilename());
1983. }
1984.
1985. }
1986. compound_statement();
1987. }
1988. else if ((_tokenSet_21.member(LA(1))) && (_tokenSet_22.member(LA(2)))) {
1989. function_declarator();
1990. {
1991. if ((_tokenSet_18.member(LA(1))) && (_tokenSet_19.member(LA(2)))) {
1992. {
1993. _loop103:
1994. do {
1995. if ((_tokenSet_1.member(LA(1)))) {
1996. declaration();
1997. }
1998. else {
1999. break _loop103;
2000. }
2001.
2002. } while (true);
2003. }
2004. }
2005. else if ((LA(1)==LCURLY) && (_tokenSet_20.member(LA(2)))) {
2006. }
2007. else {
2008. throw new NoViableAltException(LT(1), getFilename());
2009. }
2010.
2011. }
2012. compound_statement();
2013. }
2014. else {
2015. throw new NoViableAltException(LT(1), getFilename());
2016. }
2017.
2018. }
2019. }
2020.
2021. public final void decl_namespace() throws RecognitionException, TokenStreamException {
2022.
2023. Token ns = null;
2024. Token ns2 = null;
2025. String qid="";
2026.
2027. match(LITERAL_namespace);
2028. {
2029. if ((LA(1)==ID||LA(1)==LCURLY) && (_tokenSet_23.member(LA(2)))) {
2030. {
2031. switch ( LA(1)) {
2032. case ID:
2033. {
2034. ns = LT(1);
2035. match(ID);
2036. if ( inputState.guessing==0 ) {
2037. _td = true;declaratorID(ns.getText(),CPPvariables.QI_TYPE);
2038. }
2039. break;
2040. }
2041. case LCURLY:
2042. {
2043. break;
2044. }
2045. default:
2046. {
2047. throw new NoViableAltException(LT(1), getFilename());
2048. }
2049. }
2050. }
2051. match(LCURLY);
2052. if ( inputState.guessing==0 ) {
2053. m.enterNamespaceScope(ns.getText());
2054. }
2055. {
2056. _loop49:
2057. do {
2058. if ((_tokenSet_0.member(LA(1)))) {
2059. external_declaration();
2060. }
2061. else {
2062. break _loop49;
2063. }
2064.
2065. } while (true);
2066. }
2067. if ( inputState.guessing==0 ) {
2068. m.exitNamespaceScope();
2069. }
2070. match(RCURLY);
2071. }
2072. else if ((LA(1)==ID) && (LA(2)==ASSIGNEQUAL)) {
2073. ns2 = LT(1);
2074. match(ID);
2075. if ( inputState.guessing==0 ) {
2076. _td=true;declaratorID(ns2.getText(),CPPvariables.QI_TYPE);
2077. }
2078. match(ASSIGNEQUAL);
2079. qid=qualified_id();
2080. match(SEMICOLON);
2081. if ( inputState.guessing==0 ) {
2082. m.makeNamespaceAlias(qid, ns2.getText());
2083. }
2084. }
2085. else {
2086. throw new NoViableAltException(LT(1), getFilename());
2087. }
2088.
2089. }
2090. }
2091.
2092. public final String qualified_id() throws RecognitionException, TokenStreamException {
2093. String q="";
2094.
2095. Token id = null;
2096.
2097. String so="";
2098. String qitem="";
2099.
2100.
2101. so=scope_override();
2102. if ( inputState.guessing==0 ) {
2103. qitem=so;
2104. }
2105. {
2106. switch ( LA(1)) {
2107. case ID:
2108. {
2109. id = LT(1);
2110. match(ID);
2111. {
2112. if ((LA(1)==LESSTHAN) && (_tokenSet_24.member(LA(2)))) {
2113. match(LESSTHAN);
2114. template_argument_list();
2115. match(GREATERTHAN);
2116. }
2117. else if ((_tokenSet_25.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
2118. }
2119. else {
2120. throw new NoViableAltException(LT(1), getFilename());
2121. }
2122.
2123. }
2124. if ( inputState.guessing==0 ) {
2125.
2126. qitem=qitem+id.getText();
2127.
2128. }
2129. break;
2130. }
2131. case OPERATOR:
2132. {
2133. match(OPERATOR);
2134. optor();
2135. if ( inputState.guessing==0 ) {
2136. qitem=qitem+"operator"+"NYI";
2137. }
2138. break;
2139. }
2140. case LITERAL_this:
2141. {
2142. match(LITERAL_this);
2143. break;
2144. }
2145. case LITERAL_true:
2146. case LITERAL_false:
2147. {
2148. {
2149. switch ( LA(1)) {
2150. case LITERAL_true:
2151. {
2152. match(LITERAL_true);
2153. break;
2154. }
2155. case LITERAL_false:
2156. {
2157. match(LITERAL_false);
2158. break;
2159. }
2160. default:
2161. {
2162. throw new NoViableAltException(LT(1), getFilename());
2163. }
2164. }
2165. }
2166. break;
2167. }
2168. default:
2169. {
2170. throw new NoViableAltException(LT(1), getFilename());
2171. }
2172. }
2173. }
2174. if ( inputState.guessing==0 ) {
2175. q = qitem;
2176. }
2177. return q;
2178. }
2179.
2180. public final void member_declaration() throws RecognitionException, TokenStreamException {
2181.
2182. String q="";
2183.
2184. if ( inputState.guessing==0 ) {
2185. m.beginMemberDeclaration();
2186. }
2187. {
2188. switch ( LA(1)) {
2189. case LITERAL_public:
2190. case LITERAL_protected:
2191. case LITERAL_private:
2192. {
2193. access_specifier();
2194. match(COLON);
2195. break;
2196. }
2197. case SEMICOLON:
2198. {
2199. match(SEMICOLON);
2200. break;
2201. }
2202. default:
2203. boolean synPredMatched54 = false;
2204. if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
2205. int _m54 = mark();
2206. synPredMatched54 = true;
2207. inputState.guessing++;
2208. try {
2209. {
2210. {
2211. switch ( LA(1)) {
2212. case LITERAL_typedef:
2213. {
2214. match(LITERAL_typedef);
2215. break;
2216. }
2217. case LITERAL_class:
2218. case LITERAL_struct:
2219. case LITERAL_union:
2220. {
2221. break;
2222. }
2223. default:
2224. {
2225. throw new NoViableAltException(LT(1), getFilename());
2226. }
2227. }
2228. }
2229. class_head();
2230. }
2231. }
2232. catch (RecognitionException pe) {
2233. synPredMatched54 = false;
2234. }
2235. rewind(_m54);
2236. inputState.guessing--;
2237. }
2238. if ( synPredMatched54 ) {
2239. declaration();
2240. }
2241. else {
2242. boolean synPredMatched57 = false;
2243. if (((LA(1)==LITERAL_enum) && (LA(2)==ID||LA(2)==LCURLY))) {
2244. int _m57 = mark();
2245. synPredMatched57 = true;
2246. inputState.guessing++;
2247. try {
2248. {
2249. match(LITERAL_enum);
2250. {
2251. switch ( LA(1)) {
2252. case ID:
2253. {
2254. match(ID);
2255. break;
2256. }
2257. case LCURLY:
2258. {
2259. break;
2260. }
2261. default:
2262. {
2263. throw new NoViableAltException(LT(1), getFilename());
2264. }
2265. }
2266. }
2267. match(LCURLY);
2268. }
2269. }
2270. catch (RecognitionException pe) {
2271. synPredMatched57 = false;
2272. }
2273. rewind(_m57);
2274. inputState.guessing--;
2275. }
2276. if ( synPredMatched57 ) {
2277. enum_specifier();
2278. {
2279. switch ( LA(1)) {
2280. case ID:
2281. case COLON:
2282. case LITERAL__stdcall:
2283. case LITERAL___stdcall:
2284. case LPAREN:
2285. case OPERATOR:
2286. case LITERAL_this:
2287. case LITERAL_true:
2288. case LITERAL_false:
2289. case STAR:
2290. case AMPERSAND:
2291. case TILDE:
2292. case SCOPE:
2293. case LITERAL__cdecl:
2294. case LITERAL___cdecl:
2295. case LITERAL__near:
2296. case LITERAL___near:
2297. case LITERAL__far:
2298. case LITERAL___far:
2299. case LITERAL___interrupt:
2300. case LITERAL_pascal:
2301. case LITERAL__pascal:
2302. case LITERAL___pascal:
2303. {
2304. member_declarator_list();
2305. break;
2306. }
2307. case SEMICOLON:
2308. {
2309. break;
2310. }
2311. default:
2312. {
2313. throw new NoViableAltException(LT(1), getFilename());
2314. }
2315. }
2316. }
2317. match(SEMICOLON);
2318. }
2319. else {
2320. boolean synPredMatched60 = false;
2321. if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
2322. int _m60 = mark();
2323. synPredMatched60 = true;
2324. inputState.guessing++;
2325. try {
2326. {
2327. template_head();
2328. class_head();
2329. }
2330. }
2331. catch (RecognitionException pe) {
2332. synPredMatched60 = false;
2333. }
2334. rewind(_m60);
2335. inputState.guessing--;
2336. }
2337. if ( synPredMatched60 ) {
2338. template_head();
2339. declaration();
2340. }
2341. else {
2342. boolean synPredMatched62 = false;
2343. if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
2344. int _m62 = mark();
2345. synPredMatched62 = true;
2346. inputState.guessing++;
2347. try {
2348. {
2349. ctor_decl_spec();
2350. if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
2351. throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
2352. ctor_declarator();
2353. match(SEMICOLON);
2354. }
2355. }
2356. catch (RecognitionException pe) {
2357. synPredMatched62 = false;
2358. }
2359. rewind(_m62);
2360. inputState.guessing--;
2361. }
2362. if ( synPredMatched62 ) {
2363. ctor_decl_spec();
2364. ctor_declarator();
2365. match(SEMICOLON);
2366. }
2367. else {
2368. boolean synPredMatched65 = false;
2369. if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
2370. int _m65 = mark();
2371. synPredMatched65 = true;
2372. inputState.guessing++;
2373. try {
2374. {
2375. ctor_decl_spec();
2376. if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
2377. throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
2378. ctor_declarator();
2379. {
2380. switch ( LA(1)) {
2381. case COLON:
2382. {
2383. match(COLON);
2384. break;
2385. }
2386. case LCURLY:
2387. {
2388. match(LCURLY);
2389. break;
2390. }
2391. default:
2392. {
2393. throw new NoViableAltException(LT(1), getFilename());
2394. }
2395. }
2396. }
2397. }
2398. }
2399. catch (RecognitionException pe) {
2400. synPredMatched65 = false;
2401. }
2402. rewind(_m65);
2403. inputState.guessing--;
2404. }
2405. if ( synPredMatched65 ) {
2406. ctor_definition();
2407. }
2408. else {
2409. boolean synPredMatched67 = false;
2410. if (((_tokenSet_27.member(LA(1))) && (_tokenSet_4.member(LA(2))))) {
2411. int _m67 = mark();
2412. synPredMatched67 = true;
2413. inputState.guessing++;
2414. try {
2415. {
2416. dtor_head();
2417. match(SEMICOLON);
2418. }
2419. }
2420. catch (RecognitionException pe) {
2421. synPredMatched67 = false;
2422. }
2423. rewind(_m67);
2424. inputState.guessing--;
2425. }
2426. if ( synPredMatched67 ) {
2427. dtor_head();
2428. match(SEMICOLON);
2429. }
2430. else {
2431. boolean synPredMatched69 = false;
2432. if (((_tokenSet_27.member(LA(1))) && (_tokenSet_4.member(LA(2))))) {
2433. int _m69 = mark();
2434. synPredMatched69 = true;
2435. inputState.guessing++;
2436. try {
2437. {
2438. dtor_head();
2439. match(LCURLY);
2440. }
2441. }
2442. catch (RecognitionException pe) {
2443. synPredMatched69 = false;
2444. }
2445. rewind(_m69);
2446. inputState.guessing--;
2447. }
2448. if ( synPredMatched69 ) {
2449. dtor_head();
2450. dtor_body();
2451. }
2452. else {
2453. boolean synPredMatched71 = false;
2454. if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
2455. int _m71 = mark();
2456. synPredMatched71 = true;
2457. inputState.guessing++;
2458. try {
2459. {
2460. declaration_specifiers();
2461. function_declarator();
2462. match(SEMICOLON);
2463. }
2464. }
2465. catch (RecognitionException pe) {
2466. synPredMatched71 = false;
2467. }
2468. rewind(_m71);
2469. inputState.guessing--;
2470. }
2471. if ( synPredMatched71 ) {
2472. if ( inputState.guessing==0 ) {
2473. m.beginFunctionDeclaration();
2474. }
2475. declaration();
2476. if ( inputState.guessing==0 ) {
2477. m.endFunctionDeclaration();
2478. }
2479. }
2480. else {
2481. boolean synPredMatched73 = false;
2482. if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
2483. int _m73 = mark();
2484. synPredMatched73 = true;
2485. inputState.guessing++;
2486. try {
2487. {
2488. declaration_specifiers();
2489. function_declarator();
2490. match(LCURLY);
2491. }
2492. }
2493. catch (RecognitionException pe) {
2494. synPredMatched73 = false;
2495. }
2496. rewind(_m73);
2497. inputState.guessing--;
2498. }
2499. if ( synPredMatched73 ) {
2500. if ( inputState.guessing==0 ) {
2501. m.beginFunctionDefinition();
2502. }
2503. function_definition();
2504. if ( inputState.guessing==0 ) {
2505. m.endFunctionDefinition();
2506. }
2507. }
2508. else {
2509. boolean synPredMatched76 = false;
2510. if (((LA(1)==LITERAL_inline||LA(1)==OPERATOR) && (_tokenSet_28.member(LA(2))))) {
2511. int _m76 = mark();
2512. synPredMatched76 = true;
2513. inputState.guessing++;
2514. try {
2515. {
2516. {
2517. switch ( LA(1)) {
2518. case LITERAL_inline:
2519. {
2520. match(LITERAL_inline);
2521. break;
2522. }
2523. case OPERATOR:
2524. {
2525. break;
2526. }
2527. default:
2528. {
2529. throw new NoViableAltException(LT(1), getFilename());
2530. }
2531. }
2532. }
2533. conversion_function_decl_or_def();
2534. }
2535. }
2536. catch (RecognitionException pe) {
2537. synPredMatched76 = false;
2538. }
2539. rewind(_m76);
2540. inputState.guessing--;
2541. }
2542. if ( synPredMatched76 ) {
2543. {
2544. switch ( LA(1)) {
2545. case LITERAL_inline:
2546. {
2547. match(LITERAL_inline);
2548. break;
2549. }
2550. case OPERATOR:
2551. {
2552. break;
2553. }
2554. default:
2555. {
2556. throw new NoViableAltException(LT(1), getFilename());
2557. }
2558. }
2559. }
2560. conversion_function_decl_or_def();
2561. }
2562. else {
2563. boolean synPredMatched79 = false;
2564. if (((_tokenSet_29.member(LA(1))) && (_tokenSet_30.member(LA(2))))) {
2565. int _m79 = mark();
2566. synPredMatched79 = true;
2567. inputState.guessing++;
2568. try {
2569. {
2570. qualified_id();
2571. match(SEMICOLON);
2572. }
2573. }
2574. catch (RecognitionException pe) {
2575. synPredMatched79 = false;
2576. }
2577. rewind(_m79);
2578. inputState.guessing--;
2579. }
2580. if ( synPredMatched79 ) {
2581. q=qualified_id();
2582. match(SEMICOLON);
2583. }
2584. else {
2585. boolean synPredMatched81 = false;
2586. if (((_tokenSet_11.member(LA(1))) && (_tokenSet_31.member(LA(2))))) {
2587. int _m81 = mark();
2588. synPredMatched81 = true;
2589. inputState.guessing++;
2590. try {
2591. {
2592. declaration_specifiers();
2593. }
2594. }
2595. catch (RecognitionException pe) {
2596. synPredMatched81 = false;
2597. }
2598. rewind(_m81);
2599. inputState.guessing--;
2600. }
2601. if ( synPredMatched81 ) {
2602. declaration_specifiers();
2603. {
2604. switch ( LA(1)) {
2605. case ID:
2606. case COLON:
2607. case LITERAL__stdcall:
2608. case LITERAL___stdcall:
2609. case LPAREN:
2610. case OPERATOR:
2611. case LITERAL_this:
2612. case LITERAL_true:
2613. case LITERAL_false:
2614. case STAR:
2615. case AMPERSAND:
2616. case TILDE:
2617. case SCOPE:
2618. case LITERAL__cdecl:
2619. case LITERAL___cdecl:
2620. case LITERAL__near:
2621. case LITERAL___near:
2622. case LITERAL__far:
2623. case LITERAL___far:
2624. case LITERAL___interrupt:
2625. case LITERAL_pascal:
2626. case LITERAL__pascal:
2627. case LITERAL___pascal:
2628. {
2629. member_declarator_list();
2630. break;
2631. }
2632. case SEMICOLON:
2633. {
2634. break;
2635. }
2636. default:
2637. {
2638. throw new NoViableAltException(LT(1), getFilename());
2639. }
2640. }
2641. }
2642. match(SEMICOLON);
2643. }
2644. else {
2645. boolean synPredMatched84 = false;
2646. if (((_tokenSet_21.member(LA(1))) && (_tokenSet_22.member(LA(2))))) {
2647. int _m84 = mark();
2648. synPredMatched84 = true;
2649. inputState.guessing++;
2650. try {
2651. {
2652. function_declarator();
2653. match(SEMICOLON);
2654. }
2655. }
2656. catch (RecognitionException pe) {
2657. synPredMatched84 = false;
2658. }
2659. rewind(_m84);
2660. inputState.guessing--;
2661. }
2662. if ( synPredMatched84 ) {
2663. function_declarator();
2664. match(SEMICOLON);
2665. }
2666. else if ((_tokenSet_21.member(LA(1))) && (_tokenSet_22.member(LA(2)))) {
2667. function_declarator();
2668. compound_statement();
2669. }
2670. else {
2671. boolean synPredMatched87 = false;
2672. if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
2673. int _m87 = mark();
2674. synPredMatched87 = true;
2675. inputState.guessing++;
2676. try {
2677. {
2678. template_head();
2679. declaration_specifiers();
2680. {
2681. switch ( LA(1)) {
2682. case ID:
2683. case LITERAL__stdcall:
2684. case LITERAL___stdcall:
2685. case LPAREN:
2686. case OPERATOR:
2687. case LITERAL_this:
2688. case LITERAL_true:
2689. case LITERAL_false:
2690. case STAR:
2691. case AMPERSAND:
2692. case TILDE:
2693. case SCOPE:
2694. case LITERAL__cdecl:
2695. case LITERAL___cdecl:
2696. case LITERAL__near:
2697. case LITERAL___near:
2698. case LITERAL__far:
2699. case LITERAL___far:
2700. case LITERAL___interrupt:
2701. case LITERAL_pascal:
2702. case LITERAL__pascal:
2703. case LITERAL___pascal:
2704. {
2705. init_declarator_list();
2706. break;
2707. }
2708. case SEMICOLON:
2709. {
2710. break;
2711. }
2712. default:
2713. {
2714. throw new NoViableAltException(LT(1), getFilename());
2715. }
2716. }
2717. }
2718. match(SEMICOLON);
2719. }
2720. }
2721. catch (RecognitionException pe) {
2722. synPredMatched87 = false;
2723. }
2724. rewind(_m87);
2725. inputState.guessing--;
2726. }
2727. if ( synPredMatched87 ) {
2728. template_head();
2729. declaration_specifiers();
2730. {
2731. switch ( LA(1)) {
2732. case ID:
2733. case LITERAL__stdcall:
2734. case LITERAL___stdcall:
2735. case LPAREN:
2736. case OPERATOR:
2737. case LITERAL_this:
2738. case LITERAL_true:
2739. case LITERAL_false:
2740. case STAR:
2741. case AMPERSAND:
2742. case TILDE:
2743. case SCOPE:
2744. case LITERAL__cdecl:
2745. case LITERAL___cdecl:
2746. case LITERAL__near:
2747. case LITERAL___near:
2748. case LITERAL__far:
2749. case LITERAL___far:
2750. case LITERAL___interrupt:
2751. case LITERAL_pascal:
2752. case LITERAL__pascal:
2753. case LITERAL___pascal:
2754. {
2755. init_declarator_list();
2756. break;
2757. }
2758. case SEMICOLON:
2759. {
2760. break;
2761. }
2762. default:
2763. {
2764. throw new NoViableAltException(LT(1), getFilename());
2765. }
2766. }
2767. }
2768. match(SEMICOLON);
2769. }
2770. else if ((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN)) {
2771. template_head();
2772. {
2773. boolean synPredMatched91 = false;
2774. if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
2775. int _m91 = mark();
2776. synPredMatched91 = true;
2777. inputState.guessing++;
2778. try {
2779. {
2780. ctor_decl_spec();
2781. if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
2782. throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
2783. }
2784. }
2785. catch (RecognitionException pe) {
2786. synPredMatched91 = false;
2787. }
2788. rewind(_m91);
2789. inputState.guessing--;
2790. }
2791. if ( synPredMatched91 ) {
2792. ctor_definition();
2793. }
2794. else {
2795. boolean synPredMatched93 = false;
2796. if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
2797. int _m93 = mark();
2798. synPredMatched93 = true;
2799. inputState.guessing++;
2800. try {
2801. {
2802. declaration_specifiers();
2803. function_declarator();
2804. match(SEMICOLON);
2805. }
2806. }
2807. catch (RecognitionException pe) {
2808. synPredMatched93 = false;
2809. }
2810. rewind(_m93);
2811. inputState.guessing--;
2812. }
2813. if ( synPredMatched93 ) {
2814. declaration();
2815. }
2816. else {
2817. boolean synPredMatched95 = false;
2818. if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
2819. int _m95 = mark();
2820. synPredMatched95 = true;
2821. inputState.guessing++;
2822. try {
2823. {
2824. declaration_specifiers();
2825. function_declarator();
2826. match(LCURLY);
2827. }
2828. }
2829. catch (RecognitionException pe) {
2830. synPredMatched95 = false;
2831. }
2832. rewind(_m95);
2833. inputState.guessing--;
2834. }
2835. if ( synPredMatched95 ) {
2836. function_definition();
2837. }
2838. else if ((LA(1)==OPERATOR) && (_tokenSet_11.member(LA(2)))) {
2839. conversion_function_decl_or_def();
2840. }
2841. else {
2842. throw new NoViableAltException(LT(1), getFilename());
2843. }
2844. }}
2845. }
2846. }
2847. else {
2848. throw new NoViableAltException(LT(1), getFilename());
2849. }
2850. }}}}}}}}}}}}}}
2851. }
2852. if ( inputState.guessing==0 ) {
2853. m.endMemberDeclaration();
2854. }
2855. }
2856.
2857. public final void member_declarator_list() throws RecognitionException, TokenStreamException {
2858.
2859. m.beginMemberDeclaratorList();
2860.
2861. {
2862. member_declarator();
2863. {
2864. switch ( LA(1)) {
2865. case ASSIGNEQUAL:
2866. {
2867. match(ASSIGNEQUAL);
2868. match(OCTALINT);
2869. break;
2870. }
2871. case SEMICOLON:
2872. case COMMA:
2873. {
2874. break;
2875. }
2876. default:
2877. {
2878. throw new NoViableAltException(LT(1), getFilename());
2879. }
2880. }
2881. }
2882. {
2883. _loop180:
2884. do {
2885. if ((LA(1)==COMMA)) {
2886. match(COMMA);
2887. member_declarator();
2888. {
2889. switch ( LA(1)) {
2890. case ASSIGNEQUAL:
2891. {
2892. match(ASSIGNEQUAL);
2893. match(OCTALINT);
2894. break;
2895. }
2896. case SEMICOLON:
2897. case COMMA:
2898. {
2899. break;
2900. }
2901. default:
2902. {
2903. throw new NoViableAltException(LT(1), getFilename());
2904. }
2905. }
2906. }
2907. }
2908. else {
2909. break _loop180;
2910. }
2911.
2912. } while (true);
2913. }
2914. }
2915. if ( inputState.guessing==0 ) {
2916. m.endMemberDeclaratorList();
2917. }
2918. }
2919.
2920. public final void ctor_declarator() throws RecognitionException, TokenStreamException {
2921.
2922. String q="";
2923.
2924. q=qualified_ctor_id();
2925. if ( inputState.guessing==0 ) {
2926. m.qualifiedCtorId(q);
2927. }
2928. match(LPAREN);
2929. {
2930. switch ( LA(1)) {
2931. case LITERAL_typedef:
2932. case LITERAL_enum:
2933. case ID:
2934. case LITERAL_inline:
2935. case LITERAL_extern:
2936. case LITERAL__inline:
2937. case LITERAL___inline:
2938. case LITERAL_virtual:
2939. case LITERAL_explicit:
2940. case LITERAL_friend:
2941. case LITERAL__stdcall:
2942. case LITERAL___stdcall:
2943. case LITERAL__declspec:
2944. case LITERAL___declspec:
2945. case LPAREN:
2946. case LITERAL_typename:
2947. case LITERAL_auto:
2948. case LITERAL_register:
2949. case LITERAL_static:
2950. case LITERAL_mutable:
2951. case LITERAL_const:
2952. case LITERAL_const_cast:
2953. case LITERAL_volatile:
2954. case LITERAL_char:
2955. case LITERAL_wchar_t:
2956. case LITERAL_bool:
2957. case LITERAL_short:
2958. case LITERAL_int:
2959. case 44:
2960. case 45:
2961. case 46:
2962. case LITERAL_long:
2963. case LITERAL_signed:
2964. case LITERAL_unsigned:
2965. case LITERAL_float:
2966. case LITERAL_double:
2967. case LITERAL_void:
2968. case LITERAL_class:
2969. case LITERAL_struct:
2970. case LITERAL_union:
2971. case OPERATOR:
2972. case LITERAL_this:
2973. case LITERAL_true:
2974. case LITERAL_false:
2975. case STAR:
2976. case AMPERSAND:
2977. case TILDE:
2978. case ELLIPSIS:
2979. case SCOPE:
2980. case LITERAL__cdecl:
2981. case LITERAL___cdecl:
2982. case LITERAL__near:
2983. case LITERAL___near:
2984. case LITERAL__far:
2985. case LITERAL___far:
2986. case LITERAL___interrupt:
2987. case LITERAL_pascal:
2988. case LITERAL__pascal:
2989. case LITERAL___pascal:
2990. {
2991. parameter_list();
2992. break;
2993. }
2994. case RPAREN:
2995. {
2996. break;
2997. }
2998. default:
2999. {
3000. throw new NoViableAltException(LT(1), getFilename());
3001. }
3002. }
3003. }
3004. match(RPAREN);
3005. {
3006. switch ( LA(1)) {
3007. case LITERAL_throw:
3008. {
3009. exception_specification();
3010. break;
3011. }
3012. case LCURLY:
3013. case SEMICOLON:
3014. case COLON:
3015. {
3016. break;
3017. }
3018. default:
3019. {
3020. throw new NoViableAltException(LT(1), getFilename());
3021. }
3022. }
3023. }
3024. }
3025.
3026. public final void compound_statement() throws RecognitionException, TokenStreamException {
3027.
3028.
3029. if ( inputState.guessing==0 ) {
3030. m.beginCompoundStatement();
3031. }
3032. match(LCURLY);
3033. {
3034. switch ( LA(1)) {
3035. case LITERAL_typedef:
3036. case LITERAL_enum:
3037. case ID:
3038. case LCURLY:
3039. case SEMICOLON:
3040. case LITERAL_inline:
3041. case LITERAL_extern:
3042. case StringLiteral:
3043. case LITERAL__inline:
3044. case LITERAL___inline:
3045. case LITERAL_virtual:
3046. case LITERAL_explicit:
3047. case LITERAL_friend:
3048. case LITERAL__stdcall:
3049. case LITERAL___stdcall:
3050. case LITERAL__declspec:
3051. case LITERAL___declspec:
3052. case LPAREN:
3053. case LITERAL_typename:
3054. case LITERAL_auto:
3055. case LITERAL_register:
3056. case LITERAL_static:
3057. case LITERAL_mutable:
3058. case LITERAL_const:
3059. case LITERAL_const_cast:
3060. case LITERAL_volatile:
3061. case LITERAL_char:
3062. case LITERAL_wchar_t:
3063. case LITERAL_bool:
3064. case LITERAL_short:
3065. case LITERAL_int:
3066. case 44:
3067. case 45:
3068. case 46:
3069. case LITERAL_long:
3070. case LITERAL_signed:
3071. case LITERAL_unsigned:
3072. case LITERAL_float:
3073. case LITERAL_double:
3074. case LITERAL_void:
3075. case LITERAL_class:
3076. case LITERAL_struct:
3077. case LITERAL_union:
3078. case OPERATOR:
3079. case LITERAL_this:
3080. case LITERAL_true:
3081. case LITERAL_false:
3082. case OCTALINT:
3083. case STAR:
3084. case AMPERSAND:
3085. case TILDE:
3086. case LITERAL_throw:
3087. case LITERAL_case:
3088. case LITERAL_default:
3089. case LITERAL_if:
3090. case LITERAL_switch:
3091. case LITERAL_while:
3092. case LITERAL_do:
3093. case LITERAL_for:
3094. case LITERAL_goto:
3095. case LITERAL_continue:
3096. case LITERAL_break:
3097. case LITERAL_return:
3098. case LITERAL_try:
3099. case LITERAL_using:
3100. case LITERAL__asm:
3101. case LITERAL___asm:
3102. case PLUS:
3103. case MINUS:
3104. case PLUSPLUS:
3105. case MINUSMINUS:
3106. case LITERAL_sizeof:
3107. case SCOPE:
3108. case LITERAL_dynamic_cast:
3109. case LITERAL_static_cast:
3110. case LITERAL_reinterpret_cast:
3111. case NOT:
3112. case LITERAL_new:
3113. case LITERAL_delete:
3114. case DECIMALINT:
3115. case HEXADECIMALINT:
3116. case CharLiteral:
3117. case FLOATONE:
3118. case FLOATTWO:
3119. {
3120. statement_list();
3121. break;
3122. }
3123. case RCURLY:
3124. {
3125. break;
3126. }
3127. default:
3128. {
3129. throw new NoViableAltException(LT(1), getFilename());
3130. }
3131. }
3132. }
3133. match(RCURLY);
3134. if ( inputState.guessing==0 ) {
3135. m.endCompoundStatement();
3136. }
3137. }
3138.
3139. public final void access_specifier() throws RecognitionException, TokenStreamException {
3140.
3141.
3142. switch ( LA(1)) {
3143. case LITERAL_public:
3144. {
3145. match(LITERAL_public);
3146. if ( inputState.guessing==0 ) {
3147. m.accessSpecifier("public");
3148. }
3149. break;
3150. }
3151. case LITERAL_protected:
3152. {
3153. match(LITERAL_protected);
3154. if ( inputState.guessing==0 ) {
3155. m.accessSpecifier("protected");
3156. }
3157. break;
3158. }
3159. case LITERAL_private:
3160. {
3161. match(LITERAL_private);
3162. if ( inputState.guessing==0 ) {
3163. m.accessSpecifier("private");
3164. }
3165. break;
3166. }
3167. default:
3168. {
3169. throw new NoViableAltException(LT(1), getFilename());
3170. }
3171. }
3172. }
3173.
3174. public final void linkage_specification() throws RecognitionException, TokenStreamException {
3175.
3176.
3177. match(LITERAL_extern);
3178. match(StringLiteral);
3179. {
3180. switch ( LA(1)) {
3181. case LCURLY:
3182. {
3183. match(LCURLY);
3184. {
3185. _loop112:
3186. do {
3187. if ((_tokenSet_0.member(LA(1)))) {
3188. external_declaration();
3189. }
3190. else {
3191. break _loop112;
3192. }
3193.
3194. } while (true);
3195. }
3196. match(RCURLY);
3197. break;
3198. }
3199. case LITERAL_typedef:
3200. case LITERAL_enum:
3201. case ID:
3202. case LITERAL_inline:
3203. case LITERAL_extern:
3204. case LITERAL__inline:
3205. case LITERAL___inline:
3206. case LITERAL_virtual:
3207. case LITERAL_explicit:
3208. case LITERAL_friend:
3209. case LITERAL__stdcall:
3210. case LITERAL___stdcall:
3211. case LITERAL__declspec:
3212. case LITERAL___declspec:
3213. case LITERAL_typename:
3214. case LITERAL_auto:
3215. case LITERAL_register:
3216. case LITERAL_static:
3217. case LITERAL_mutable:
3218. case LITERAL_const:
3219. case LITERAL_const_cast:
3220. case LITERAL_volatile:
3221. case LITERAL_char:
3222. case LITERAL_wchar_t:
3223. case LITERAL_bool:
3224. case LITERAL_short:
3225. case LITERAL_int:
3226. case 44:
3227. case 45:
3228. case 46:
3229. case LITERAL_long:
3230. case LITERAL_signed:
3231. case LITERAL_unsigned:
3232. case LITERAL_float:
3233. case LITERAL_double:
3234. case LITERAL_void:
3235. case LITERAL_class:
3236. case LITERAL_struct:
3237. case LITERAL_union:
3238. case LITERAL_using:
3239. case SCOPE:
3240. {
3241. declaration();
3242. break;
3243. }
3244. default:
3245. {
3246. throw new NoViableAltException(LT(1), getFilename());
3247. }
3248. }
3249. }
3250. }
3251.
3252. public final void using_declaration() throws RecognitionException, TokenStreamException {
3253.
3254. String qid="";
3255.
3256. match(LITERAL_using);
3257. {
3258. switch ( LA(1)) {
3259. case LITERAL_namespace:
3260. {
3261. match(LITERAL_namespace);
3262. qid=qualified_id();
3263. break;
3264. }
3265. case ID:
3266. case OPERATOR:
3267. case LITERAL_this:
3268. case LITERAL_true:
3269. case LITERAL_false:
3270. case SCOPE:
3271. {
3272. qid=qualified_id();
3273. break;
3274. }
3275. default:
3276. {
3277. throw new NoViableAltException(LT(1), getFilename());
3278. }
3279. }
3280. }
3281. match(SEMICOLON);
3282. }
3283.
3284. public final void storage_class_specifier() throws RecognitionException, TokenStreamException {
3285.
3286.
3287. switch ( LA(1)) {
3288. case LITERAL_auto:
3289. {
3290. match(LITERAL_auto);
3291. if ( inputState.guessing==0 ) {
3292. m.storageClassSpecifier("auto");
3293. }
3294. break;
3295. }
3296. case LITERAL_register:
3297. {
3298. match(LITERAL_register);
3299. if ( inputState.guessing==0 ) {
3300. m.storageClassSpecifier("register");
3301. }
3302. break;
3303. }
3304. case LITERAL_static:
3305. {
3306. match(LITERAL_static);
3307. if ( inputState.guessing==0 ) {
3308. m.storageClassSpecifier("static");
3309. }
3310. break;
3311. }
3312. case LITERAL_extern:
3313. {
3314. match(LITERAL_extern);
3315. if ( inputState.guessing==0 ) {
3316. m.storageClassSpecifier("extern");
3317. }
3318. break;
3319. }
3320. case LITERAL_mutable:
3321. {
3322. match(LITERAL_mutable);
3323. if ( inputState.guessing==0 ) {
3324. m.storageClassSpecifier("mutable");
3325. }
3326. break;
3327. }
3328. default:
3329. {
3330. throw new NoViableAltException(LT(1), getFilename());
3331. }
3332. }
3333. }
3334.
3335. public final void type_qualifier() throws RecognitionException, TokenStreamException {
3336.
3337.
3338. switch ( LA(1)) {
3339. case LITERAL_const:
3340. case LITERAL_const_cast:
3341. {
3342. {
3343. switch ( LA(1)) {
3344. case LITERAL_const:
3345. {
3346. match(LITERAL_const);
3347. break;
3348. }
3349. case LITERAL_const_cast:
3350. {
3351. match(LITERAL_const_cast);
3352. break;
3353. }
3354. default:
3355. {
3356. throw new NoViableAltException(LT(1), getFilename());
3357. }
3358. }
3359. }
3360. if ( inputState.guessing==0 ) {
3361. m.typeQualifier("const");
3362. }
3363. break;
3364. }
3365. case LITERAL_volatile:
3366. {
3367. match(LITERAL_volatile);
3368. if ( inputState.guessing==0 ) {
3369. m.typeQualifier("volatile");
3370. }
3371. break;
3372. }
3373. default:
3374. {
3375. throw new NoViableAltException(LT(1), getFilename());
3376. }
3377. }
3378. }
3379.
3380. public final void type_specifier() throws RecognitionException, TokenStreamException {
3381.
3382.
3383. switch ( LA(1)) {
3384. case ID:
3385. case LITERAL__declspec:
3386. case LITERAL___declspec:
3387. case LITERAL_char:
3388. case LITERAL_wchar_t:
3389. case LITERAL_bool:
3390. case LITERAL_short:
3391. case LITERAL_int:
3392. case 44:
3393. case 45:
3394. case 46:
3395. case LITERAL_long:
3396. case LITERAL_signed:
3397. case LITERAL_unsigned:
3398. case LITERAL_float:
3399. case LITERAL_double:
3400. case LITERAL_void:
3401. case SCOPE:
3402. {
3403. simple_type_specifier();
3404. break;
3405. }
3406. case LITERAL_class:
3407. case LITERAL_struct:
3408. case LITERAL_union:
3409. {
3410. class_specifier();
3411. break;
3412. }
3413. case LITERAL_enum:
3414. {
3415. enum_specifier();
3416. break;
3417. }
3418. default:
3419. {
3420. throw new NoViableAltException(LT(1), getFilename());
3421. }
3422. }
3423. }
3424.
3425. public final void direct_declarator() throws RecognitionException, TokenStreamException {
3426.
3427. Token dtor = null;
3428. String id="";
3429.
3430. switch ( LA(1)) {
3431. case TILDE:
3432. {
3433. match(TILDE);
3434. dtor = LT(1);
3435. match(ID);
3436. if ( inputState.guessing==0 ) {
3437. declaratorID(dtor.getText(),CPPvariables.QI_DTOR);
3438. }
3439. match(LPAREN);
3440. {
3441. switch ( LA(1)) {
3442. case LITERAL_typedef:
3443. case LITERAL_enum:
3444. case ID:
3445. case LITERAL_inline:
3446. case LITERAL_extern:
3447. case LITERAL__inline:
3448. case LITERAL___inline:
3449. case LITERAL_virtual:
3450. case LITERAL_explicit:
3451. case LITERAL_friend:
3452. case LITERAL__stdcall:
3453. case LITERAL___stdcall:
3454. case LITERAL__declspec:
3455. case LITERAL___declspec:
3456. case LPAREN:
3457. case LITERAL_typename:
3458. case LITERAL_auto:
3459. case LITERAL_register:
3460. case LITERAL_static:
3461. case LITERAL_mutable:
3462. case LITERAL_const:
3463. case LITERAL_const_cast:
3464. case LITERAL_volatile:
3465. case LITERAL_char:
3466. case LITERAL_wchar_t:
3467. case LITERAL_bool:
3468. case LITERAL_short:
3469. case LITERAL_int:
3470. case 44:
3471. case 45:
3472. case 46:
3473. case LITERAL_long:
3474. case LITERAL_signed:
3475. case LITERAL_unsigned:
3476. case LITERAL_float:
3477. case LITERAL_double:
3478. case LITERAL_void:
3479. case LITERAL_class:
3480. case LITERAL_struct:
3481. case LITERAL_union:
3482. case OPERATOR:
3483. case LITERAL_this:
3484. case LITERAL_true:
3485. case LITERAL_false:
3486. case STAR:
3487. case AMPERSAND:
3488. case TILDE:
3489. case ELLIPSIS:
3490. case SCOPE:
3491. case LITERAL__cdecl:
3492. case LITERAL___cdecl:
3493. case LITERAL__near:
3494. case LITERAL___near:
3495. case LITERAL__far:
3496. case LITERAL___far:
3497. case LITERAL___interrupt:
3498. case LITERAL_pascal:
3499. case LITERAL__pascal:
3500. case LITERAL___pascal:
3501. {
3502. parameter_list();
3503. break;
3504. }
3505. case RPAREN:
3506. {
3507. break;
3508. }
3509. default:
3510. {
3511. throw new NoViableAltException(LT(1), getFilename());
3512. }
3513. }
3514. }
3515. match(RPAREN);
3516. break;
3517. }
3518. case LPAREN:
3519. {
3520. match(LPAREN);
3521. declarator();
3522. match(RPAREN);
3523. declarator_suffixes();
3524. break;
3525. }
3526. default:
3527. boolean synPredMatched203 = false;
3528. if (((_tokenSet_29.member(LA(1))) && (_tokenSet_16.member(LA(2))))) {
3529. int _m203 = mark();
3530. synPredMatched203 = true;
3531. inputState.guessing++;
3532. try {
3533. {
3534. qualified_id();
3535. match(LPAREN);
3536. {
3537. switch ( LA(1)) {
3538. case RPAREN:
3539. {
3540. match(RPAREN);
3541. break;
3542. }
3543. case LITERAL_typedef:
3544. case LITERAL_enum:
3545. case ID:
3546. case LITERAL_inline:
3547. case LITERAL_extern:
3548. case LITERAL__inline:
3549. case LITERAL___inline:
3550. case LITERAL_virtual:
3551. case LITERAL_explicit:
3552. case LITERAL_friend:
3553. case LITERAL__stdcall:
3554. case LITERAL___stdcall:
3555. case LITERAL__declspec:
3556. case LITERAL___declspec:
3557. case LITERAL_typename:
3558. case LITERAL_auto:
3559. case LITERAL_register:
3560. case LITERAL_static:
3561. case LITERAL_mutable:
3562. case LITERAL_const:
3563. case LITERAL_const_cast:
3564. case LITERAL_volatile:
3565. case LITERAL_char:
3566. case LITERAL_wchar_t:
3567. case LITERAL_bool:
3568. case LITERAL_short:
3569. case LITERAL_int:
3570. case 44:
3571. case 45:
3572. case 46:
3573. case LITERAL_long:
3574. case LITERAL_signed:
3575. case LITERAL_unsigned:
3576. case LITERAL_float:
3577. case LITERAL_double:
3578. case LITERAL_void:
3579. case LITERAL_class:
3580. case LITERAL_struct:
3581. case LITERAL_union:
3582. case SCOPE:
3583. {
3584. declaration_specifiers();
3585. break;
3586. }
3587. default:
3588. {
3589. throw new NoViableAltException(LT(1), getFilename());
3590. }
3591. }
3592. }
3593. }
3594. }
3595. catch (RecognitionException pe) {
3596. synPredMatched203 = false;
3597. }
3598. rewind(_m203);
3599. inputState.guessing--;
3600. }
3601. if ( synPredMatched203 ) {
3602. id=qualified_id();
3603. if ( inputState.guessing==0 ) {
3604. declaratorID(id,CPPvariables.QI_FUN); m.directDeclarator(id, _td);
3605. }
3606. match(LPAREN);
3607. {
3608. switch ( LA(1)) {
3609. case LITERAL_typedef:
3610. case LITERAL_enum:
3611. case ID:
3612. case LITERAL_inline:
3613. case LITERAL_extern:
3614. case LITERAL__inline:
3615. case LITERAL___inline:
3616. case LITERAL_virtual:
3617. case LITERAL_explicit:
3618. case LITERAL_friend:
3619. case LITERAL__stdcall:
3620. case LITERAL___stdcall:
3621. case LITERAL__declspec:
3622. case LITERAL___declspec:
3623. case LPAREN:
3624. case LITERAL_typename:
3625. case LITERAL_auto:
3626. case LITERAL_register:
3627. case LITERAL_static:
3628. case LITERAL_mutable:
3629. case LITERAL_const:
3630. case LITERAL_const_cast:
3631. case LITERAL_volatile:
3632. case LITERAL_char:
3633. case LITERAL_wchar_t:
3634. case LITERAL_bool:
3635. case LITERAL_short:
3636. case LITERAL_int:
3637. case 44:
3638. case 45:
3639. case 46:
3640. case LITERAL_long:
3641. case LITERAL_signed:
3642. case LITERAL_unsigned:
3643. case LITERAL_float:
3644. case LITERAL_double:
3645. case LITERAL_void:
3646. case LITERAL_class:
3647. case LITERAL_struct:
3648. case LITERAL_union:
3649. case OPERATOR:
3650. case LITERAL_this:
3651. case LITERAL_true:
3652. case LITERAL_false:
3653. case STAR:
3654. case AMPERSAND:
3655. case TILDE:
3656. case ELLIPSIS:
3657. case SCOPE:
3658. case LITERAL__cdecl:
3659. case LITERAL___cdecl:
3660. case LITERAL__near:
3661. case LITERAL___near:
3662. case LITERAL__far:
3663. case LITERAL___far:
3664. case LITERAL___interrupt:
3665. case LITERAL_pascal:
3666. case LITERAL__pascal:
3667. case LITERAL___pascal:
3668. {
3669. parameter_list();
3670. break;
3671. }
3672. case RPAREN:
3673. {
3674. break;
3675. }
3676. default:
3677. {
3678. throw new NoViableAltException(LT(1), getFilename());
3679. }
3680. }
3681. }
3682. match(RPAREN);
3683. {
3684. _loop206:
3685. do {
3686. if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL_volatile))) {
3687. type_qualifier();
3688. }
3689. else {
3690. break _loop206;
3691. }
3692.
3693. } while (true);
3694. }
3695. {
3696. switch ( LA(1)) {
3697. case LITERAL_throw:
3698. {
3699. exception_specification();
3700. break;
3701. }
3702. case LESSTHAN:
3703. case GREATERTHAN:
3704. case ID:
3705. case SEMICOLON:
3706. case RCURLY:
3707. case ASSIGNEQUAL:
3708. case COLON:
3709. case COMMA:
3710. case LITERAL__stdcall:
3711. case LITERAL___stdcall:
3712. case LPAREN:
3713. case RPAREN:
3714. case OPERATOR:
3715. case LITERAL_this:
3716. case LITERAL_true:
3717. case LITERAL_false:
3718. case STAR:
3719. case AMPERSAND:
3720. case LSQUARE:
3721. case RSQUARE:
3722. case TILDE:
3723. case ELLIPSIS:
3724. case TIMESEQUAL:
3725. case DIVIDEEQUAL:
3726. case MINUSEQUAL:
3727. case PLUSEQUAL:
3728. case MODEQUAL:
3729. case SHIFTLEFTEQUAL:
3730. case SHIFTRIGHTEQUAL:
3731. case BITWISEANDEQUAL:
3732. case BITWISEXOREQUAL:
3733. case BITWISEOREQUAL:
3734. case QUESTIONMARK:
3735. case OR:
3736. case AND:
3737. case BITWISEOR:
3738. case BITWISEXOR:
3739. case NOTEQUAL:
3740. case EQUAL:
3741. case LESSTHANOREQUALTO:
3742. case GREATERTHANOREQUALTO:
3743. case SHIFTLEFT:
3744. case SHIFTRIGHT:
3745. case PLUS:
3746. case MINUS:
3747. case DIVIDE:
3748. case MOD:
3749. case DOTMBR:
3750. case POINTERTOMBR:
3751. case SCOPE:
3752. case LITERAL__cdecl:
3753. case LITERAL___cdecl:
3754. case LITERAL__near:
3755. case LITERAL___near:
3756. case LITERAL__far:
3757. case LITERAL___far:
3758. case LITERAL___interrupt:
3759. case LITERAL_pascal:
3760. case LITERAL__pascal:
3761. case LITERAL___pascal:
3762. {
3763. break;
3764. }
3765. default:
3766. {
3767. throw new NoViableAltException(LT(1), getFilename());
3768. }
3769. }
3770. }
3771. }
3772. else {
3773. boolean synPredMatched209 = false;
3774. if (((_tokenSet_29.member(LA(1))) && (_tokenSet_16.member(LA(2))))) {
3775. int _m209 = mark();
3776. synPredMatched209 = true;
3777. inputState.guessing++;
3778. try {
3779. {
3780. qualified_id();
3781. match(LPAREN);
3782. qualified_id();
3783. }
3784. }
3785. catch (RecognitionException pe) {
3786. synPredMatched209 = false;
3787. }
3788. rewind(_m209);
3789. inputState.guessing--;
3790. }
3791. if ( synPredMatched209 ) {
3792. id=qualified_id();
3793. if ( inputState.guessing==0 ) {
3794. declaratorID(id,CPPvariables.QI_VAR);
3795. }
3796. match(LPAREN);
3797. expression_list();
3798. match(RPAREN);
3799. }
3800. else {
3801. boolean synPredMatched211 = false;
3802. if (((_tokenSet_29.member(LA(1))) && (_tokenSet_16.member(LA(2))))) {
3803. int _m211 = mark();
3804. synPredMatched211 = true;
3805. inputState.guessing++;
3806. try {
3807. {
3808. qualified_id();
3809. match(LSQUARE);
3810. }
3811. }
3812. catch (RecognitionException pe) {
3813. synPredMatched211 = false;
3814. }
3815. rewind(_m211);
3816. inputState.guessing--;
3817. }
3818. if ( synPredMatched211 ) {
3819. id=qualified_id();
3820. if ( inputState.guessing==0 ) {
3821.
3822. if (_td==true)
3823. declaratorID(id,CPPvariables.QI_TYPE);
3824. else
3825. declaratorID(id,CPPvariables.QI_VAR);
3826.
3827. }
3828. {
3829. int _cnt214=0;
3830. _loop214:
3831. do {
3832. if ((LA(1)==LSQUARE) && (_tokenSet_32.member(LA(2)))) {
3833. match(LSQUARE);
3834. {
3835. switch ( LA(1)) {
3836. case ID:
3837. case StringLiteral:
3838. case LITERAL__declspec:
3839. case LITERAL___declspec:
3840. case LPAREN:
3841. case LITERAL_const_cast:
3842. case LITERAL_char:
3843. case LITERAL_wchar_t:
3844. case LITERAL_bool:
3845. case LITERAL_short:
3846. case LITERAL_int:
3847. case 44:
3848. case 45:
3849. case 46:
3850. case LITERAL_long:
3851. case LITERAL_signed:
3852. case LITERAL_unsigned:
3853. case LITERAL_float:
3854. case LITERAL_double:
3855. case LITERAL_void:
3856. case OPERATOR:
3857. case LITERAL_this:
3858. case LITERAL_true:
3859. case LITERAL_false:
3860. case OCTALINT:
3861. case STAR:
3862. case AMPERSAND:
3863. case TILDE:
3864. case PLUS:
3865. case MINUS:
3866. case PLUSPLUS:
3867. case MINUSMINUS:
3868. case LITERAL_sizeof:
3869. case SCOPE:
3870. case LITERAL_dynamic_cast:
3871. case LITERAL_static_cast:
3872. case LITERAL_reinterpret_cast:
3873. case NOT:
3874. case LITERAL_new:
3875. case LITERAL_delete:
3876. case DECIMALINT:
3877. case HEXADECIMALINT:
3878. case CharLiteral:
3879. case FLOATONE:
3880. case FLOATTWO:
3881. {
3882. constant_expression();
3883. break;
3884. }
3885. case RSQUARE:
3886. {
3887. break;
3888. }
3889. default:
3890. {
3891. throw new NoViableAltException(LT(1), getFilename());
3892. }
3893. }
3894. }
3895. match(RSQUARE);
3896. }
3897. else {
3898. if ( _cnt214>=1 ) { break _loop214; } else {throw new NoViableAltException(LT(1), getFilenam...3899. }
3900.
3901. _cnt214++;
3902. } while (true);
3903. }
3904. }
3905. else if ((_tokenSet_29.member(LA(1))) && (_tokenSet_33.member(LA(2)))) {
3906. id=qualified_id();
3907. if ( inputState.guessing==0 ) {
3908.
3909. if (_td==true)
3910. declaratorID(id,CPPvariables.QI_TYPE);
3911. else
3912. declaratorID(id,CPPvariables.QI_VAR);
3913. m.directDeclarator(id, _td);
3914.
3915. }
3916. }
3917. else {
3918. throw new NoViableAltException(LT(1), getFilename());
3919. }
3920. }}}
3921. }
3922.
3923. public final void simple_type_specifier() throws RecognitionException, TokenStreamException {
3924.
3925. String s="";
3926. java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone();
3927. auxBitSet.or(CPPvariables.QI_CTOR);
3928. List sts = new ArrayList();
3929.
3930.
3931. {
3932. if (((LA(1)==ID||LA(1)==SCOPE))&&(qualifiedItemIsOneOf(auxBitSet,0))) {
3933. s=qualified_type();
3934. if ( inputState.guessing==0 ) {
3935. sts.add(s); m.simpleTypeSpecifier(sts);
3936. }
3937. }
3938. else if ((_tokenSet_34.member(LA(1)))) {
3939. {
3940. int _cnt129=0;
3941. _loop129:
3942. do {
3943. switch ( LA(1)) {
3944. case LITERAL_char:
3945. {
3946. match(LITERAL_char);
3947. if ( inputState.guessing==0 ) {
3948. sts.add("char");
3949. }
3950. break;
3951. }
3952. case LITERAL_wchar_t:
3953. {
3954. match(LITERAL_wchar_t);
3955. if ( inputState.guessing==0 ) {
3956. sts.add("wchar_t");
3957. }
3958. break;
3959. }
3960. case LITERAL_bool:
3961. {
3962. match(LITERAL_bool);
3963. if ( inputState.guessing==0 ) {
3964. sts.add("bool");
3965. }
3966. break;
3967. }
3968. case LITERAL_short:
3969. {
3970. match(LITERAL_short);
3971. if ( inputState.guessing==0 ) {
3972. sts.add("short");
3973. }
3974. break;
3975. }
3976. case LITERAL_int:
3977. {
3978. match(LITERAL_int);
3979. if ( inputState.guessing==0 ) {
3980. sts.add("int");
3981. }
3982. break;
3983. }
3984. case 44:
3985. case 45:
3986. {
3987. {
3988. switch ( LA(1)) {
3989. case 44:
3990. {
3991. match(44);
3992. break;
3993. }
3994. case 45:
3995. {
3996. match(45);
3997. break;
3998. }
3999. default:
4000. {
4001. throw new NoViableAltException(LT(1), getFilename());
4002. }
4003. }
4004. }
4005. if ( inputState.guessing==0 ) {
4006. sts.add("__int64");
4007. }
4008. break;
4009. }
4010. case 46:
4011. {
4012. match(46);
4013. if ( inputState.guessing==0 ) {
4014. sts.add("__w64");
4015. }
4016. break;
4017. }
4018. case LITERAL_long:
4019. {
4020. match(LITERAL_long);
4021. if ( inputState.guessing==0 ) {
4022. sts.add("long");
4023. }
4024. break;
4025. }
4026. case LITERAL_signed:
4027. {
4028. match(LITERAL_signed);
4029. if ( inputState.guessing==0 ) {
4030. sts.add("signed");
4031. }
4032. break;
4033. }
4034. case LITERAL_unsigned:
4035. {
4036. match(LITERAL_unsigned);
4037. if ( inputState.guessing==0 ) {
4038. sts.add("unsigned");
4039. }
4040. break;
4041. }
4042. case LITERAL_float:
4043. {
4044. match(LITERAL_float);
4045. if ( inputState.guessing==0 ) {
4046. sts.add("float");
4047. }
4048. break;
4049. }
4050. case LITERAL_double:
4051. {
4052. match(LITERAL_double);
4053. if ( inputState.guessing==0 ) {
4054. sts.add("double");
4055. }
4056. break;
4057. }
4058. case LITERAL_void:
4059. {
4060. match(LITERAL_void);
4061. if ( inputState.guessing==0 ) {
4062. sts.add("void");
4063. }
4064. break;
4065. }
4066. case LITERAL__declspec:
4067. case LITERAL___declspec:
4068. {
4069. {
4070. switch ( LA(1)) {
4071. case LITERAL__declspec:
4072. {
4073. match(LITERAL__declspec);
4074. break;
4075. }
4076. case LITERAL___declspec:
4077. {
4078. match(LITERAL___declspec);
4079. break;
4080. }
4081. default:
4082. {
4083. throw new NoViableAltException(LT(1), getFilename());
4084. }
4085. }
4086. }
4087. match(LPAREN);
4088. match(ID);
4089. match(RPAREN);
4090. break;
4091. }
4092. default:
4093. {
4094. if ( _cnt129>=1 ) { break _loop129; } else {throw new NoViableAltException(LT(1), getFilename()...4095. }
4096. }
4097. _cnt129++;
4098. } while (true);
4099. }
4100. if ( inputState.guessing==0 ) {
4101. m.simpleTypeSpecifier(sts);
4102. }
4103. }
4104. else {
4105. throw new NoViableAltException(LT(1), getFilename());
4106. }
4107.
4108. }
4109. }
4110.
4111. public final void class_specifier() throws RecognitionException, TokenStreamException {
4112.
4113. String saveClass="";String id="";String type="";
4114.
4115. {
4116. switch ( LA(1)) {
4117. case LITERAL_class:
4118. {
4119. match(LITERAL_class);
4120. if ( inputState.guessing==0 ) {
4121. type=CPPvariables.OT_CLASS;
4122. }
4123. break;
4124. }
4125. case LITERAL_struct:
4126. {
4127. match(LITERAL_struct);
4128. if ( inputState.guessing==0 ) {
4129. type=CPPvariables.OT_STRUCT;
4130. }
4131. break;
4132. }
4133. case LITERAL_union:
4134. {
4135. match(LITERAL_union);
4136. if ( inputState.guessing==0 ) {
4137. type=CPPvariables.OT_UNION;
4138. }
4139. break;
4140. }
4141. default:
4142. {
4143. throw new NoViableAltException(LT(1), getFilename());
4144. }
4145. }
4146. }
4147. {
4148. switch ( LA(1)) {
4149. case ID:
4150. case OPERATOR:
4151. case LITERAL_this:
4152. case LITERAL_true:
4153. case LITERAL_false:
4154. case SCOPE:
4155. {
4156. id=qualified_id();
4157. {
4158. if ((LA(1)==LCURLY||LA(1)==COLON) && (_tokenSet_35.member(LA(2)))) {
4159. if ( inputState.guessing==0 ) {
4160. saveClass = enclosingClass;
4161. enclosingClass = id;
4162.
4163. }
4164. if ( inputState.guessing==0 ) {
4165. m.beginClassDefinition(type, id);
4166. }
4167. {
4168. switch ( LA(1)) {
4169. case COLON:
4170. {
4171. base_clause();
4172. break;
4173. }
4174. case LCURLY:
4175. {
4176. break;
4177. }
4178. default:
4179. {
4180. throw new NoViableAltException(LT(1), getFilename());
4181. }
4182. }
4183. }
4184. match(LCURLY);
4185. if ( inputState.guessing==0 ) {
4186.
4187. if(!symbols.containsKey(id))
4188. symbols.put(id,type);
4189.
4190. }
4191. {
4192. _loop138:
4193. do {
4194. if ((_tokenSet_36.member(LA(1)))) {
4195. member_declaration();
4196. }
4197. else {
4198. break _loop138;
4199. }
4200.
4201. } while (true);
4202. }
4203. if ( inputState.guessing==0 ) {
4204. m.endClassDefinition();
4205. }
4206. match(RCURLY);
4207. if ( inputState.guessing==0 ) {
4208. enclosingClass = saveClass;
4209. }
4210. }
4211. else if ((_tokenSet_37.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
4212. if ( inputState.guessing==0 ) {
4213.
4214.
4215. String auxName=id;
4216. int pos = auxName.indexOf("::");
4217. while(pos>=0)
4218. {
4219. if(!symbols.containsKey(auxName.substring(0,pos)))
4220. symbols.put(auxName.substring(0,pos),type);
4221. auxName=auxName.substring(pos+2,auxName.length());
4222. pos=auxName.indexOf("::");
4223. }
4224. if(!symbols.containsKey(auxName))
4225. symbols.put(auxName,type);
4226.
4227. }
4228. }
4229. else {
4230. throw new NoViableAltException(LT(1), getFilename());
4231. }
4232.
4233. }
4234. break;
4235. }
4236. case LCURLY:
4237. {
4238. match(LCURLY);
4239. if ( inputState.guessing==0 ) {
4240. id="anonymous";
4241. saveClass = enclosingClass; enclosingClass = "anonymous";
4242. if(!symbols.containsKey(id))
4243. symbols.put(id,type);
4244.
4245. }
4246. {
4247. _loop140:
4248. do {
4249. if ((_tokenSet_36.member(LA(1)))) {
4250. member_declaration();
4251. }
4252. else {
4253. break _loop140;
4254. }
4255.
4256. } while (true);
4257. }
4258. match(RCURLY);
4259. if ( inputState.guessing==0 ) {
4260. enclosingClass = saveClass;
4261. }
4262. break;
4263. }
4264. default:
4265. {
4266. throw new NoViableAltException(LT(1), getFilename());
4267. }
4268. }
4269. }
4270. }
4271.
4272. public final String qualified_type() throws RecognitionException, TokenStreamException {
4273. String q="";
4274.
4275. Token id = null;
4276. String s=""; String qitem="";
4277.
4278. s=scope_override();
4279. id = LT(1);
4280. match(ID);
4281. {
4282. if ((LA(1)==LESSTHAN) && (_tokenSet_24.member(LA(2)))) {
4283. match(LESSTHAN);
4284. template_argument_list();
4285. match(GREATERTHAN);
4286. }
4287. else if ((_tokenSet_25.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
4288. }
4289. else {
4290. throw new NoViableAltException(LT(1), getFilename());
4291. }
4292.
4293. }
4294. if ( inputState.guessing==0 ) {
4295.
4296. qitem=s;
4297. qitem=qitem+id.getText();
4298. q=qitem;
4299.
4300. }
4301. return q;
4302. }
4303.
4304. public final void template_argument_list() throws RecognitionException, TokenStreamException {
4305.
4306.
4307. template_argument();
4308. {
4309. _loop304:
4310. do {
4311. if ((LA(1)==COMMA)) {
4312. match(COMMA);
4313. template_argument();
4314. }
4315. else {
4316. break _loop304;
4317. }
4318.
4319. } while (true);
4320. }
4321. }
4322.
4323. public final void base_clause() throws RecognitionException, TokenStreamException {
4324.
4325.
4326. match(COLON);
4327. base_specifier();
4328. {
4329. _loop170:
4330. do {
4331. if ((LA(1)==COMMA)) {
4332. match(COMMA);
4333. base_specifier();
4334. }
4335. else {
4336. break _loop170;
4337. }
4338.
4339. } while (true);
4340. }
4341. }
4342.
4343. public final void enumerator_list() throws RecognitionException, TokenStreamException {
4344.
4345.
4346. enumerator();
4347. {
4348. _loop146:
4349. do {
4350. if ((LA(1)==COMMA)) {
4351. match(COMMA);
4352. enumerator();
4353. }
4354. else {
4355. break _loop146;
4356. }
4357.
4358. } while (true);
4359. }
4360. }
4361.
4362. public final void enumerator() throws RecognitionException, TokenStreamException {
4363.
4364. Token id = null;
4365.
4366. id = LT(1);
4367. match(ID);
4368. {
4369. switch ( LA(1)) {
4370. case ASSIGNEQUAL:
4371. {
4372. match(ASSIGNEQUAL);
4373. constant_expression();
4374. break;
4375. }
4376. case RCURLY:
4377. case COMMA:
4378. {
4379. break;
4380. }
4381. default:
4382. {
4383. throw new NoViableAltException(LT(1), getFilename());
4384. }
4385. }
4386. }
4387. }
4388.
4389. public final void constant_expression() throws RecognitionException, TokenStreamException {
4390.
4391.
4392. conditional_expression();
4393. }
4394.
4395. public final void optor() throws RecognitionException, TokenStreamException {
4396.
4397.
4398. switch ( LA(1)) {
4399. case LITERAL_new:
4400. {
4401. match(LITERAL_new);
4402. {
4403. if ((LA(1)==LSQUARE) && (LA(2)==RSQUARE)) {
4404. match(LSQUARE);
4405. match(RSQUARE);
4406. }
4407. else if ((_tokenSet_38.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
4408. }
4409. else {
4410. throw new NoViableAltException(LT(1), getFilename());
4411. }
4412.
4413. }
4414. break;
4415. }
4416. case LITERAL_delete:
4417. {
4418. match(LITERAL_delete);
4419. {
4420. if ((LA(1)==LSQUARE) && (LA(2)==RSQUARE)) {
4421. match(LSQUARE);
4422. match(RSQUARE);
4423. }
4424. else if ((_tokenSet_38.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
4425. }
4426. else {
4427. throw new NoViableAltException(LT(1), getFilename());
4428. }
4429.
4430. }
4431. break;
4432. }
4433. case LPAREN:
4434. {
4435. match(LPAREN);
4436. match(RPAREN);
4437. break;
4438. }
4439. case LSQUARE:
4440. {
4441. match(LSQUARE);
4442. match(RSQUARE);
4443. break;
4444. }
4445. case LESSTHAN:
4446. case GREATERTHAN:
4447. case ASSIGNEQUAL:
4448. case COMMA:
4449. case STAR:
4450. case AMPERSAND:
4451. case TILDE:
4452. case TIMESEQUAL:
4453. case DIVIDEEQUAL:
4454. case MINUSEQUAL:
4455. case PLUSEQUAL:
4456. case MODEQUAL:
4457. case SHIFTLEFTEQUAL:
4458. case SHIFTRIGHTEQUAL:
4459. case BITWISEANDEQUAL:
4460. case BITWISEXOREQUAL:
4461. case BITWISEOREQUAL:
4462. case OR:
4463. case AND:
4464. case BITWISEOR:
4465. case BITWISEXOR:
4466. case NOTEQUAL:
4467. case EQUAL:
4468. case LESSTHANOREQUALTO:
4469. case GREATERTHANOREQUALTO:
4470. case SHIFTLEFT:
4471. case SHIFTRIGHT:
4472. case PLUS:
4473. case MINUS:
4474. case DIVIDE:
4475. case MOD:
4476. case POINTERTOMBR:
4477. case PLUSPLUS:
4478. case MINUSMINUS:
4479. case POINTERTO:
4480. case NOT:
4481. {
4482. optor_simple_tokclass();
4483. break;
4484. }
4485. default:
4486. {
4487. throw new NoViableAltException(LT(1), getFilename());
4488. }
4489. }
4490. }
4491.
4492. public final void typeID() throws RecognitionException, TokenStreamException {
4493.
4494.
4495. if (!(isTypeName(LT(1).getText())))
4496. throw new SemanticException("isTypeName(LT(1).getText())");
4497. match(ID);
4498. }
4499.
4500. public final void init_declarator() throws RecognitionException, TokenStreamException {
4501.
4502.
4503. declarator();
4504. {
4505. switch ( LA(1)) {
4506. case ASSIGNEQUAL:
4507. {
4508. match(ASSIGNEQUAL);
4509. initializer();
4510. break;
4511. }
4512. case LPAREN:
4513. {
4514. match(LPAREN);
4515. expression_list();
4516. match(RPAREN);
4517. break;
4518. }
4519. case SEMICOLON:
4520. case COMMA:
4521. {
4522. break;
4523. }
4524. default:
4525. {
4526. throw new NoViableAltException(LT(1), getFilename());
4527. }
4528. }
4529. }
4530. }
4531.
4532. public final void declarator() throws RecognitionException, TokenStreamException {
4533.
4534.
4535. boolean synPredMatched199 = false;
4536. if (((_tokenSet_13.member(LA(1))) && (_tokenSet_39.member(LA(2))))) {
4537. int _m199 = mark();
4538. synPredMatched199 = true;
4539. inputState.guessing++;
4540. try {
4541. {
4542. ptr_operator();
4543. }
4544. }
4545. catch (RecognitionException pe) {
4546. synPredMatched199 = false;
4547. }
4548. rewind(_m199);
4549. inputState.guessing--;
4550. }
4551. if ( synPredMatched199 ) {
4552. ptr_operator();
4553. declarator();
4554. }
4555. else if ((_tokenSet_40.member(LA(1))) && (_tokenSet_41.member(LA(2)))) {
4556. direct_declarator();
4557. }
4558. else {
4559. throw new NoViableAltException(LT(1), getFilename());
4560. }
4561.
4562. }
4563.
4564. public final void initializer() throws RecognitionException, TokenStreamException {
4565.
4566.
4567. if ( inputState.guessing==0 ) {
4568. m.beginInitializer();
4569. }
4570. {
4571. switch ( LA(1)) {
4572. case ID:
4573. case StringLiteral:
4574. case LITERAL__declspec:
4575. case LITERAL___declspec:
4576. case LPAREN:
4577. case LITERAL_const_cast:
4578. case LITERAL_char:
4579. case LITERAL_wchar_t:
4580. case LITERAL_bool:
4581. case LITERAL_short:
4582. case LITERAL_int:
4583. case 44:
4584. case 45:
4585. case 46:
4586. case LITERAL_long:
4587. case LITERAL_signed:
4588. case LITERAL_unsigned:
4589. case LITERAL_float:
4590. case LITERAL_double:
4591. case LITERAL_void:
4592. case OPERATOR:
4593. case LITERAL_this:
4594. case LITERAL_true:
4595. case LITERAL_false:
4596. case OCTALINT:
4597. case STAR:
4598. case AMPERSAND:
4599. case TILDE:
4600. case PLUS:
4601. case MINUS:
4602. case PLUSPLUS:
4603. case MINUSMINUS:
4604. case LITERAL_sizeof:
4605. case SCOPE:
4606. case LITERAL_dynamic_cast:
4607. case LITERAL_static_cast:
4608. case LITERAL_reinterpret_cast:
4609. case NOT:
4610. case LITERAL_new:
4611. case LITERAL_delete:
4612. case DECIMALINT:
4613. case HEXADECIMALINT:
4614. case CharLiteral:
4615. case FLOATONE:
4616. case FLOATTWO:
4617. {
4618. remainder_expression();
4619. break;
4620. }
4621. case LCURLY:
4622. {
4623. match(LCURLY);
4624. initializer();
4625. {
4626. _loop162:
4627. do {
4628. if ((LA(1)==COMMA)) {
4629. match(COMMA);
4630. initializer();
4631. }
4632. else {
4633. break _loop162;
4634. }
4635.
4636. } while (true);
4637. }
4638. match(RCURLY);
4639. break;
4640. }
4641. default:
4642. {
4643. throw new NoViableAltException(LT(1), getFilename());
4644. }
4645. }
4646. }
4647. if ( inputState.guessing==0 ) {
4648. m.endInitializer();
4649. }
4650. }
4651.
4652. public final void expression_list() throws RecognitionException, TokenStreamException {
4653.
4654.
4655. assignment_expression();
4656. {
4657. _loop465:
4658. do {
4659. if ((LA(1)==COMMA)) {
4660. match(COMMA);
4661. assignment_expression();
4662. }
4663. else {
4664. break _loop465;
4665. }
4666.
4667. } while (true);
4668. }
4669. }
4670.
4671. public final void remainder_expression() throws RecognitionException, TokenStreamException {
4672.
4673.
4674. {
4675. boolean synPredMatched355 = false;
4676. if (((_tokenSet_42.member(LA(1))) && (_tokenSet_43.member(LA(2))))) {
4677. int _m355 = mark();
4678. synPredMatched355 = true;
4679. inputState.guessing++;
4680. try {
4681. {
4682. conditional_expression();
4683. {
4684. switch ( LA(1)) {
4685. case COMMA:
4686. {
4687. match(COMMA);
4688. break;
4689. }
4690. case SEMICOLON:
4691. {
4692. match(SEMICOLON);
4693. break;
4694. }
4695. case RPAREN:
4696. {
4697. match(RPAREN);
4698. break;
4699. }
4700. default:
4701. {
4702. throw new NoViableAltException(LT(1), getFilename());
4703. }
4704. }
4705. }
4706. }
4707. }
4708. catch (RecognitionException pe) {
4709. synPredMatched355 = false;
4710. }
4711. rewind(_m355);
4712. inputState.guessing--;
4713. }
4714. if ( synPredMatched355 ) {
4715. assignment_expression();
4716. }
4717. else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_43.member(LA(2)))) {
4718. assignment_expression();
4719. }
4720. else {
4721. throw new NoViableAltException(LT(1), getFilename());
4722. }
4723.
4724. }
4725. }
4726.
4727. public final void base_specifier() throws RecognitionException, TokenStreamException {
4728.
4729. String qt=""; m.beginBaseSpecifier();
4730.
4731. {
4732. switch ( LA(1)) {
4733. case LITERAL_virtual:
4734. {
4735. match(LITERAL_virtual);
4736. {
4737. switch ( LA(1)) {
4738. case LITERAL_public:
4739. case LITERAL_protected:
4740. case LITERAL_private:
4741. {
4742. access_specifier();
4743. break;
4744. }
4745. case ID:
4746. case SCOPE:
4747. {
4748. break;
4749. }
4750. default:
4751. {
4752. throw new NoViableAltException(LT(1), getFilename());
4753. }
4754. }
4755. }
4756. qt=qualified_type();
4757. if ( inputState.guessing==0 ) {
4758. m.baseSpecifier(qt, true);
4759. }
4760. break;
4761. }
4762. case ID:
4763. case SCOPE:
4764. {
4765. qt=qualified_type();
4766. if ( inputState.guessing==0 ) {
4767. m.baseSpecifier(qt, false);
4768. }
4769. break;
4770. }
4771. default:
4772. if (((LA(1) >= LITERAL_public && LA(1) <= LITERAL_private)) && (LA(2)==LITERAL_virtual)) {
4773. access_specifier();
4774. match(LITERAL_virtual);
4775. qt=qualified_type();
4776. if ( inputState.guessing==0 ) {
4777. m.baseSpecifier(qt, true);
4778. }
4779. }
4780. else if (((LA(1) >= LITERAL_public && LA(1) <= LITERAL_private)) && (LA(2)==ID||LA(2)==SCOPE)) {
...4781. access_specifier();
4782. qt=qualified_type();
4783. if ( inputState.guessing==0 ) {
4784. m.baseSpecifier(qt, false);
4785. }
4786. }
4787. else {
4788. throw new NoViableAltException(LT(1), getFilename());
4789. }
4790. }
4791. }
4792. if ( inputState.guessing==0 ) {
4793. m.endBaseSpecifier();
4794. }
4795. }
4796.
4797. public final void member_declarator() throws RecognitionException, TokenStreamException {
4798.
4799. m.beginMemberDeclarator();
4800.
4801. {
4802. boolean synPredMatched185 = false;
4803. if (((LA(1)==ID||LA(1)==COLON) && (_tokenSet_44.member(LA(2))))) {
4804. int _m185 = mark();
4805. synPredMatched185 = true;
4806. inputState.guessing++;
4807. try {
4808. {
4809. {
4810. switch ( LA(1)) {
4811. case ID:
4812. {
4813. match(ID);
4814. break;
4815. }
4816. case COLON:
4817. {
4818. break;
4819. }
4820. default:
4821. {
4822. throw new NoViableAltException(LT(1), getFilename());
4823. }
4824. }
4825. }
4826. match(COLON);
4827. constant_expression();
4828. }
4829. }
4830. catch (RecognitionException pe) {
4831. synPredMatched185 = false;
4832. }
4833. rewind(_m185);
4834. inputState.guessing--;
4835. }
4836. if ( synPredMatched185 ) {
4837. {
4838. switch ( LA(1)) {
4839. case ID:
4840. {
4841. match(ID);
4842. break;
4843. }
4844. case COLON:
4845. {
4846. break;
4847. }
4848. default:
4849. {
4850. throw new NoViableAltException(LT(1), getFilename());
4851. }
4852. }
4853. }
4854. match(COLON);
4855. constant_expression();
4856. }
4857. else if ((_tokenSet_45.member(LA(1))) && (_tokenSet_46.member(LA(2)))) {
4858. declarator();
4859. }
4860. else {
4861. throw new NoViableAltException(LT(1), getFilename());
4862. }
4863.
4864. }
4865. if ( inputState.guessing==0 ) {
4866. m.endMemberDeclarator();
4867. }
4868. }
4869.
4870. public final void template_parameter_list() throws RecognitionException, TokenStreamException {
4871.
4872.
4873. template_parameter();
4874. {
4875. _loop293:
4876. do {
4877. if ((LA(1)==COMMA)) {
4878. match(COMMA);
4879. template_parameter();
4880. }
4881. else {
4882. break _loop293;
4883. }
4884.
4885. } while (true);
4886. }
4887. }
4888.
4889. public final void parameter_list() throws RecognitionException, TokenStreamException {
4890.
4891.
4892. parameter_declaration_list();
4893. {
4894. switch ( LA(1)) {
4895. case ELLIPSIS:
4896. {
4897. match(ELLIPSIS);
4898. break;
4899. }
4900. case RPAREN:
4901. {
4902. break;
4903. }
4904. default:
4905. {
4906. throw new NoViableAltException(LT(1), getFilename());
4907. }
4908. }
4909. }
4910. }
4911.
4912. public final void exception_specification() throws RecognitionException, TokenStreamException {
4913.
4914. String so="";
4915.
4916. match(LITERAL_throw);
4917. match(LPAREN);
4918. {
4919. switch ( LA(1)) {
4920. case ID:
4921. case RPAREN:
4922. case SCOPE:
4923. {
4924. {
4925. switch ( LA(1)) {
4926. case ID:
4927. case SCOPE:
4928. {
4929. so=scope_override();
4930. match(ID);
4931. {
4932. _loop289:
4933. do {
4934. if ((LA(1)==COMMA)) {
4935. match(COMMA);
4936. so=scope_override();
4937. match(ID);
4938. }
4939. else {
4940. break _loop289;
4941. }
4942.
4943. } while (true);
4944. }
4945. break;
4946. }
4947. case RPAREN:
4948. {
4949. break;
4950. }
4951. default:
4952. {
4953. throw new NoViableAltException(LT(1), getFilename());
4954. }
4955. }
4956. }
4957. break;
4958. }
4959. case ELLIPSIS:
4960. {
4961. match(ELLIPSIS);
4962. break;
4963. }
4964. default:
4965. {
4966. throw new NoViableAltException(LT(1), getFilename());
4967. }
4968. }
4969. }
4970. match(RPAREN);
4971. }
4972.
4973. public final void cv_qualifier_seq() throws RecognitionException, TokenStreamException {
4974.
4975.
4976. {
4977. _loop196:
4978. do {
4979. if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL_volatile))) {
4980. type_qualifier();
4981. }
4982. else {
4983. break _loop196;
4984. }
4985.
4986. } while (true);
4987. }
4988. }
4989.
4990. public final void ptr_operator() throws RecognitionException, TokenStreamException {
4991.
4992.
4993. if ( inputState.guessing==0 ) {
4994. m.beginPtrOperator();
4995. }
4996. {
4997. switch ( LA(1)) {
4998. case AMPERSAND:
4999. {
5000. match(AMPERSAND);
5001. if ( inputState.guessing==0 ) {
5002. m.ptrOperator("&");
5003. }
5004. break;
5005. }
5006. case LITERAL__cdecl:
5007. case LITERAL___cdecl:
5008. {
5009. {
5010. switch ( LA(1)) {
5011. case LITERAL__cdecl:
5012. {
5013. match(LITERAL__cdecl);
5014. break;
5015. }
5016. case LITERAL___cdecl:
5017. {
5018. match(LITERAL___cdecl);
5019. break;
5020. }
5021. default:
5022. {
5023. throw new NoViableAltException(LT(1), getFilename());
5024. }
5025. }
5026. }
5027. break;
5028. }
5029. case LITERAL__near:
5030. case LITERAL___near:
5031. {
5032. {
5033. switch ( LA(1)) {
5034. case LITERAL__near:
5035. {
5036. match(LITERAL__near);
5037. break;
5038. }
5039. case LITERAL___near:
5040. {
5041. match(LITERAL___near);
5042. break;
5043. }
5044. default:
5045. {
5046. throw new NoViableAltException(LT(1), getFilename());
5047. }
5048. }
5049. }
5050. break;
5051. }
5052. case LITERAL__far:
5053. case LITERAL___far:
5054. {
5055. {
5056. switch ( LA(1)) {
5057. case LITERAL__far:
5058. {
5059. match(LITERAL__far);
5060. break;
5061. }
5062. case LITERAL___far:
5063. {
5064. match(LITERAL___far);
5065. break;
5066. }
5067. default:
5068. {
5069. throw new NoViableAltException(LT(1), getFilename());
5070. }
5071. }
5072. }
5073. break;
5074. }
5075. case LITERAL___interrupt:
5076. {
5077. match(LITERAL___interrupt);
5078. break;
5079. }
5080. case LITERAL_pascal:
5081. case LITERAL__pascal:
5082. case LITERAL___pascal:
5083. {
5084. {
5085. switch ( LA(1)) {
5086. case LITERAL_pascal:
5087. {
5088. match(LITERAL_pascal);
5089. break;
5090. }
5091. case LITERAL__pascal:
5092. {
5093. match(LITERAL__pascal);
5094. break;
5095. }
5096. case LITERAL___pascal:
5097. {
5098. match(LITERAL___pascal);
5099. break;
5100. }
5101. default:
5102. {
5103. throw new NoViableAltException(LT(1), getFilename());
5104. }
5105. }
5106. }
5107. break;
5108. }
5109. case LITERAL__stdcall:
5110. case LITERAL___stdcall:
5111. {
5112. {
5113. switch ( LA(1)) {
5114. case LITERAL__stdcall:
5115. {
5116. match(LITERAL__stdcall);
5117. break;
5118. }
5119. case LITERAL___stdcall:
5120. {
5121. match(LITERAL___stdcall);
5122. break;
5123. }
5124. default:
5125. {
5126. throw new NoViableAltException(LT(1), getFilename());
5127. }
5128. }
5129. }
5130. break;
5131. }
5132. case ID:
5133. case STAR:
5134. case SCOPE:
5135. {
5136. ptr_to_member();
5137. break;
5138. }
5139. default:
5140. {
5141. throw new NoViableAltException(LT(1), getFilename());
5142. }
5143. }
5144. }
5145. if ( inputState.guessing==0 ) {
5146. m.endPtrOperator();
5147. }
5148. }
5149.
5150. public final void declarator_suffixes() throws RecognitionException, TokenStreamException {
5151.
5152. java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone(); auxBitSet.or(CPPvariabl...5153.
5154. {
5155. if ((LA(1)==LSQUARE)) {
5156. {
5157. int _cnt220=0;
5158. _loop220:
5159. do {
5160. if ((LA(1)==LSQUARE) && (_tokenSet_32.member(LA(2)))) {
5161. match(LSQUARE);
5162. {
5163. switch ( LA(1)) {
5164. case ID:
5165. case StringLiteral:
5166. case LITERAL__declspec:
5167. case LITERAL___declspec:
5168. case LPAREN:
5169. case LITERAL_const_cast:
5170. case LITERAL_char:
5171. case LITERAL_wchar_t:
5172. case LITERAL_bool:
5173. case LITERAL_short:
5174. case LITERAL_int:
5175. case 44:
5176. case 45:
5177. case 46:
5178. case LITERAL_long:
5179. case LITERAL_signed:
5180. case LITERAL_unsigned:
5181. case LITERAL_float:
5182. case LITERAL_double:
5183. case LITERAL_void:
5184. case OPERATOR:
5185. case LITERAL_this:
5186. case LITERAL_true:
5187. case LITERAL_false:
5188. case OCTALINT:
5189. case STAR:
5190. case AMPERSAND:
5191. case TILDE:
5192. case PLUS:
5193. case MINUS:
5194. case PLUSPLUS:
5195. case MINUSMINUS:
5196. case LITERAL_sizeof:
5197. case SCOPE:
5198. case LITERAL_dynamic_cast:
5199. case LITERAL_static_cast:
5200. case LITERAL_reinterpret_cast:
5201. case NOT:
5202. case LITERAL_new:
5203. case LITERAL_delete:
5204. case DECIMALINT:
5205. case HEXADECIMALINT:
5206. case CharLiteral:
5207. case FLOATONE:
5208. case FLOATTWO:
5209. {
5210. constant_expression();
5211. break;
5212. }
5213. case RSQUARE:
5214. {
5215. break;
5216. }
5217. default:
5218. {
5219. throw new NoViableAltException(LT(1), getFilename());
5220. }
5221. }
5222. }
5223. match(RSQUARE);
5224. }
5225. else {
5226. if ( _cnt220>=1 ) { break _loop220; } else {throw new NoViableAltException(LT(1), getFilename()...5227. }
5228.
5229. _cnt220++;
5230. } while (true);
5231. }
5232. }
5233. else if (((LA(1)==LPAREN))&&((!((LA(1)==LPAREN)&&(LA(2)==ID))||(qualifiedItemIsOneOf(auxBitSet,1))...5234. match(LPAREN);
5235. {
5236. switch ( LA(1)) {
5237. case LITERAL_typedef:
5238. case LITERAL_enum:
5239. case ID:
5240. case LITERAL_inline:
5241. case LITERAL_extern:
5242. case LITERAL__inline:
5243. case LITERAL___inline:
5244. case LITERAL_virtual:
5245. case LITERAL_explicit:
5246. case LITERAL_friend:
5247. case LITERAL__stdcall:
5248. case LITERAL___stdcall:
5249. case LITERAL__declspec:
5250. case LITERAL___declspec:
5251. case LPAREN:
5252. case LITERAL_typename:
5253. case LITERAL_auto:
5254. case LITERAL_register:
5255. case LITERAL_static:
5256. case LITERAL_mutable:
5257. case LITERAL_const:
5258. case LITERAL_const_cast:
5259. case LITERAL_volatile:
5260. case LITERAL_char:
5261. case LITERAL_wchar_t:
5262. case LITERAL_bool:
5263. case LITERAL_short:
5264. case LITERAL_int:
5265. case 44:
5266. case 45:
5267. case 46:
5268. case LITERAL_long:
5269. case LITERAL_signed:
5270. case LITERAL_unsigned:
5271. case LITERAL_float:
5272. case LITERAL_double:
5273. case LITERAL_void:
5274. case LITERAL_class:
5275. case LITERAL_struct:
5276. case LITERAL_union:
5277. case OPERATOR:
5278. case LITERAL_this:
5279. case LITERAL_true:
5280. case LITERAL_false:
5281. case STAR:
5282. case AMPERSAND:
5283. case TILDE:
5284. case ELLIPSIS:
5285. case SCOPE:
5286. case LITERAL__cdecl:
5287. case LITERAL___cdecl:
5288. case LITERAL__near:
5289. case LITERAL___near:
5290. case LITERAL__far:
5291. case LITERAL___far:
5292. case LITERAL___interrupt:
5293. case LITERAL_pascal:
5294. case LITERAL__pascal:
5295. case LITERAL___pascal:
5296. {
5297. parameter_list();
5298. break;
5299. }
5300. case RPAREN:
5301. {
5302. break;
5303. }
5304. default:
5305. {
5306. throw new NoViableAltException(LT(1), getFilename());
5307. }
5308. }
5309. }
5310. match(RPAREN);
5311. {
5312. _loop223:
5313. do {
5314. if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL_volatile))) {
5315. type_qualifier();
5316. }
5317. else {
5318. break _loop223;
5319. }
5320.
5321. } while (true);
5322. }
5323. {
5324. switch ( LA(1)) {
5325. case LITERAL_throw:
5326. {
5327. exception_specification();
5328. break;
5329. }
5330. case LESSTHAN:
5331. case GREATERTHAN:
5332. case ID:
5333. case SEMICOLON:
5334. case RCURLY:
5335. case ASSIGNEQUAL:
5336. case COLON:
5337. case COMMA:
5338. case LITERAL__stdcall:
5339. case LITERAL___stdcall:
5340. case LPAREN:
5341. case RPAREN:
5342. case OPERATOR:
5343. case LITERAL_this:
5344. case LITERAL_true:
5345. case LITERAL_false:
5346. case STAR:
5347. case AMPERSAND:
5348. case LSQUARE:
5349. case RSQUARE:
5350. case TILDE:
5351. case ELLIPSIS:
5352. case TIMESEQUAL:
5353. case DIVIDEEQUAL:
5354. case MINUSEQUAL:
5355. case PLUSEQUAL:
5356. case MODEQUAL:
5357. case SHIFTLEFTEQUAL:
5358. case SHIFTRIGHTEQUAL:
5359. case BITWISEANDEQUAL:
5360. case BITWISEXOREQUAL:
5361. case BITWISEOREQUAL:
5362. case QUESTIONMARK:
5363. case OR:
5364. case AND:
5365. case BITWISEOR:
5366. case BITWISEXOR:
5367. case NOTEQUAL:
5368. case EQUAL:
5369. case LESSTHANOREQUALTO:
5370. case GREATERTHANOREQUALTO:
5371. case SHIFTLEFT:
5372. case SHIFTRIGHT:
5373. case PLUS:
5374. case MINUS:
5375. case DIVIDE:
5376. case MOD:
5377. case DOTMBR:
5378. case POINTERTOMBR:
5379. case SCOPE:
5380. case LITERAL__cdecl:
5381. case LITERAL___cdecl:
5382. case LITERAL__near:
5383. case LITERAL___near:
5384. case LITERAL__far:
5385. case LITERAL___far:
5386. case LITERAL___interrupt:
5387. case LITERAL_pascal:
5388. case LITERAL__pascal:
5389. case LITERAL___pascal:
5390. {
5391. break;
5392. }
5393. default:
5394. {
5395. throw new NoViableAltException(LT(1), getFilename());
5396. }
5397. }
5398. }
5399. }
5400. else {
5401. throw new NoViableAltException(LT(1), getFilename());
5402. }
5403.
5404. }
5405. }
5406.
5407. public final void function_direct_declarator() throws RecognitionException, TokenStreamException {
...5408.
5409. String q="";
5410.
5411. {
5412. switch ( LA(1)) {
5413. case LPAREN:
5414. {
5415. match(LPAREN);
5416. q=qualified_id();
5417. if ( inputState.guessing==0 ) {
5418.
5419. declaratorID(q,CPPvariables.QI_FUN);
5420.
5421. }
5422. match(RPAREN);
5423. break;
5424. }
5425. case ID:
5426. case OPERATOR:
5427. case LITERAL_this:
5428. case LITERAL_true:
5429. case LITERAL_false:
5430. case SCOPE:
5431. {
5432. q=qualified_id();
5433. if ( inputState.guessing==0 ) {
5434.
5435. declaratorID(q,CPPvariables.QI_FUN);
5436.
5437. }
5438. break;
5439. }
5440. default:
5441. {
5442. throw new NoViableAltException(LT(1), getFilename());
5443. }
5444. }
5445. }
5446. if ( inputState.guessing==0 ) {
5447. m.functionDirectDeclarator(q);
5448. }
5449. match(LPAREN);
5450. {
5451. switch ( LA(1)) {
5452. case LITERAL_typedef:
5453. case LITERAL_enum:
5454. case ID:
5455. case LITERAL_inline:
5456. case LITERAL_extern:
5457. case LITERAL__inline:
5458. case LITERAL___inline:
5459. case LITERAL_virtual:
5460. case LITERAL_explicit:
5461. case LITERAL_friend:
5462. case LITERAL__stdcall:
5463. case LITERAL___stdcall:
5464. case LITERAL__declspec:
5465. case LITERAL___declspec:
5466. case LPAREN:
5467. case LITERAL_typename:
5468. case LITERAL_auto:
5469. case LITERAL_register:
5470. case LITERAL_static:
5471. case LITERAL_mutable:
5472. case LITERAL_const:
5473. case LITERAL_const_cast:
5474. case LITERAL_volatile:
5475. case LITERAL_char:
5476. case LITERAL_wchar_t:
5477. case LITERAL_bool:
5478. case LITERAL_short:
5479. case LITERAL_int:
5480. case 44:
5481. case 45:
5482. case 46:
5483. case LITERAL_long:
5484. case LITERAL_signed:
5485. case LITERAL_unsigned:
5486. case LITERAL_float:
5487. case LITERAL_double:
5488. case LITERAL_void:
5489. case LITERAL_class:
5490. case LITERAL_struct:
5491. case LITERAL_union:
5492. case OPERATOR:
5493. case LITERAL_this:
5494. case LITERAL_true:
5495. case LITERAL_false:
5496. case STAR:
5497. case AMPERSAND:
5498. case TILDE:
5499. case ELLIPSIS:
5500. case SCOPE:
5501. case LITERAL__cdecl:
5502. case LITERAL___cdecl:
5503. case LITERAL__near:
5504. case LITERAL___near:
5505. case LITERAL__far:
5506. case LITERAL___far:
5507. case LITERAL___interrupt:
5508. case LITERAL_pascal:
5509. case LITERAL__pascal:
5510. case LITERAL___pascal:
5511. {
5512. parameter_list();
5513. break;
5514. }
5515. case RPAREN:
5516. {
5517. break;
5518. }
5519. default:
5520. {
5521. throw new NoViableAltException(LT(1), getFilename());
5522. }
5523. }
5524. }
5525. match(RPAREN);
5526. {
5527. _loop232:
5528. do {
5529. if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL_volatile)) && (_tokenSet_47.member(LA(2)))) {
5530. type_qualifier();
5531. }
5532. else {
5533. break _loop232;
5534. }
5535.
5536. } while (true);
5537. }
5538. {
5539. switch ( LA(1)) {
5540. case ASSIGNEQUAL:
5541. {
5542. match(ASSIGNEQUAL);
5543. match(OCTALINT);
5544. break;
5545. }
5546. case LITERAL_typedef:
5547. case LITERAL_enum:
5548. case ID:
5549. case LCURLY:
5550. case SEMICOLON:
5551. case LITERAL_inline:
5552. case LITERAL_extern:
5553. case LITERAL__inline:
5554. case LITERAL___inline:
5555. case LITERAL_virtual:
5556. case LITERAL_explicit:
5557. case LITERAL_friend:
5558. case LITERAL__stdcall:
5559. case LITERAL___stdcall:
5560. case LITERAL__declspec:
5561. case LITERAL___declspec:
5562. case LITERAL_typename:
5563. case LITERAL_auto:
5564. case LITERAL_register:
5565. case LITERAL_static:
5566. case LITERAL_mutable:
5567. case LITERAL_const:
5568. case LITERAL_const_cast:
5569. case LITERAL_volatile:
5570. case LITERAL_char:
5571. case LITERAL_wchar_t:
5572. case LITERAL_bool:
5573. case LITERAL_short:
5574. case LITERAL_int:
5575. case 44:
5576. case 45:
5577. case 46:
5578. case LITERAL_long:
5579. case LITERAL_signed:
5580. case LITERAL_unsigned:
5581. case LITERAL_float:
5582. case LITERAL_double:
5583. case LITERAL_void:
5584. case LITERAL_class:
5585. case LITERAL_struct:
5586. case LITERAL_union:
5587. case LITERAL_throw:
5588. case LITERAL_using:
5589. case SCOPE:
5590. {
5591. break;
5592. }
5593. default:
5594. {
5595. throw new NoViableAltException(LT(1), getFilename());
5596. }
5597. }
5598. }
5599. {
5600. switch ( LA(1)) {
5601. case LITERAL_throw:
5602. {
5603. exception_specification();
5604. break;
5605. }
5606. case LITERAL_typedef:
5607. case LITERAL_enum:
5608. case ID:
5609. case LCURLY:
5610. case SEMICOLON:
5611. case LITERAL_inline:
5612. case LITERAL_extern:
5613. case LITERAL__inline:
5614. case LITERAL___inline:
5615. case LITERAL_virtual:
5616. case LITERAL_explicit:
5617. case LITERAL_friend:
5618. case LITERAL__stdcall:
5619. case LITERAL___stdcall:
5620. case LITERAL__declspec:
5621. case LITERAL___declspec:
5622. case LITERAL_typename:
5623. case LITERAL_auto:
5624. case LITERAL_register:
5625. case LITERAL_static:
5626. case LITERAL_mutable:
5627. case LITERAL_const:
5628. case LITERAL_const_cast:
5629. case LITERAL_volatile:
5630. case LITERAL_char:
5631. case LITERAL_wchar_t:
5632. case LITERAL_bool:
5633. case LITERAL_short:
5634. case LITERAL_int:
5635. case 44:
5636. case 45:
5637. case 46:
5638. case LITERAL_long:
5639. case LITERAL_signed:
5640. case LITERAL_unsigned:
5641. case LITERAL_float:
5642. case LITERAL_double:
5643. case LITERAL_void:
5644. case LITERAL_class:
5645. case LITERAL_struct:
5646. case LITERAL_union:
5647. case LITERAL_using:
5648. case SCOPE:
5649. {
5650. break;
5651. }
5652. default:
5653. {
5654. throw new NoViableAltException(LT(1), getFilename());
5655. }
5656. }
5657. }
5658. }
5659.
5660. public final void ctor_head() throws RecognitionException, TokenStreamException {
5661.
5662.
5663. ctor_decl_spec();
5664. ctor_declarator();
5665. }
5666.
5667. public final void ctor_body() throws RecognitionException, TokenStreamException {
5668.
5669.
5670. {
5671. switch ( LA(1)) {
5672. case COLON:
5673. {
5674. ctor_initializer();
5675. break;
5676. }
5677. case LCURLY:
5678. {
5679. break;
5680. }
5681. default:
5682. {
5683. throw new NoViableAltException(LT(1), getFilename());
5684. }
5685. }
5686. }
5687. compound_statement();
5688. }
5689.
5690. public final String qualified_ctor_id() throws RecognitionException, TokenStreamException {
5691. String q="";
5692.
5693. Token id = null;
5694.
5695. String so="";
5696. String qitem="";
5697.
5698.
5699. so=scope_override();
5700. if ( inputState.guessing==0 ) {
5701. qitem=so;
5702. }
5703. id = LT(1);
5704. match(ID);
5705. if ( inputState.guessing==0 ) {
5706. qitem=qitem+id.getText();
5707. q = qitem;
5708. }
5709. return q;
5710. }
5711.
5712. public final void ctor_initializer() throws RecognitionException, TokenStreamException {
5713.
5714.
5715. match(COLON);
5716. superclass_init();
5717. {
5718. _loop249:
5719. do {
5720. if ((LA(1)==COMMA)) {
5721. match(COMMA);
5722. superclass_init();
5723. }
5724. else {
5725. break _loop249;
5726. }
5727.
5728. } while (true);
5729. }
5730. }
5731.
5732. public final void superclass_init() throws RecognitionException, TokenStreamException {
5733.
5734. String q="";
5735.
5736. q=qualified_id();
5737. match(LPAREN);
5738. {
5739. switch ( LA(1)) {
5740. case ID:
5741. case StringLiteral:
5742. case LITERAL__declspec:
5743. case LITERAL___declspec:
5744. case LPAREN:
5745. case LITERAL_const_cast:
5746. case LITERAL_char:
5747. case LITERAL_wchar_t:
5748. case LITERAL_bool:
5749. case LITERAL_short:
5750. case LITERAL_int:
5751. case 44:
5752. case 45:
5753. case 46:
5754. case LITERAL_long:
5755. case LITERAL_signed:
5756. case LITERAL_unsigned:
5757. case LITERAL_float:
5758. case LITERAL_double:
5759. case LITERAL_void:
5760. case OPERATOR:
5761. case LITERAL_this:
5762. case LITERAL_true:
5763. case LITERAL_false:
5764. case OCTALINT:
5765. case STAR:
5766. case AMPERSAND:
5767. case TILDE:
5768. case PLUS:
5769. case MINUS:
5770. case PLUSPLUS:
5771. case MINUSMINUS:
5772. case LITERAL_sizeof:
5773. case SCOPE:
5774. case LITERAL_dynamic_cast:
5775. case LITERAL_static_cast:
5776. case LITERAL_reinterpret_cast:
5777. case NOT:
5778. case LITERAL_new:
5779. case LITERAL_delete:
5780. case DECIMALINT:
5781. case HEXADECIMALINT:
5782. case CharLiteral:
5783. case FLOATONE:
5784. case FLOATTWO:
5785. {
5786. expression_list();
5787. break;
5788. }
5789. case RPAREN:
5790. {
5791. break;
5792. }
5793. default:
5794. {
5795. throw new NoViableAltException(LT(1), getFilename());
5796. }
5797. }
5798. }
5799. match(RPAREN);
5800. }
5801.
5802. public final void dtor_decl_spec() throws RecognitionException, TokenStreamException {
5803.
5804. List declSpecs = new ArrayList();
5805.
5806. {
5807. _loop256:
5808. do {
5809. switch ( LA(1)) {
5810. case LITERAL_inline:
5811. case LITERAL__inline:
5812. case LITERAL___inline:
5813. {
5814. {
5815. switch ( LA(1)) {
5816. case LITERAL_inline:
5817. {
5818. match(LITERAL_inline);
5819. break;
5820. }
5821. case LITERAL__inline:
5822. {
5823. match(LITERAL__inline);
5824. break;
5825. }
5826. case LITERAL___inline:
5827. {
5828. match(LITERAL___inline);
5829. break;
5830. }
5831. default:
5832. {
5833. throw new NoViableAltException(LT(1), getFilename());
5834. }
5835. }
5836. }
5837. if ( inputState.guessing==0 ) {
5838. declSpecs.add("inline");
5839. }
5840. break;
5841. }
5842. case LITERAL_virtual:
5843. {
5844. match(LITERAL_virtual);
5845. if ( inputState.guessing==0 ) {
5846. declSpecs.add("virtual");
5847. }
5848. break;
5849. }
5850. default:
5851. {
5852. break _loop256;
5853. }
5854. }
5855. } while (true);
5856. }
5857. if ( inputState.guessing==0 ) {
5858. m.declarationSpecifiers(declSpecs);
5859. }
5860. }
5861.
5862. public final void dtor_declarator() throws RecognitionException, TokenStreamException {
5863.
5864. Token id = null;
5865. String s="";
5866.
5867. s=scope_override();
5868. match(TILDE);
5869. id = LT(1);
5870. match(ID);
5871. if ( inputState.guessing==0 ) {
5872. m.dtorDeclarator(s+"~"+id.getText());
5873. }
5874. match(LPAREN);
5875. match(RPAREN);
5876. {
5877. switch ( LA(1)) {
5878. case LITERAL_throw:
5879. {
5880. exception_specification();
5881. break;
5882. }
5883. case LCURLY:
5884. case SEMICOLON:
5885. {
5886. break;
5887. }
5888. default:
5889. {
5890. throw new NoViableAltException(LT(1), getFilename());
5891. }
5892. }
5893. }
5894. }
5895.
5896. public final void parameter_declaration_list() throws RecognitionException, TokenStreamException {
...5897.
5898.
5899. {
5900. parameter_declaration();
5901. {
5902. _loop265:
5903. do {
5904. if ((LA(1)==COMMA)) {
5905. match(COMMA);
5906. parameter_declaration();
5907. }
5908. else {
5909. break _loop265;
5910. }
5911.
5912. } while (true);
5913. }
5914. }
5915. }
5916.
5917. public final void parameter_declaration() throws RecognitionException, TokenStreamException {
5918.
5919. java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone(); auxBitSet.or(CPPvariabl...5920.
5921. if ( inputState.guessing==0 ) {
5922. m.beginParameterDeclaration();
5923. }
5924. {
5925. if (((_tokenSet_11.member(LA(1))) && (_tokenSet_48.member(LA(2))))&&(!((LA(1)==SCOPE) && (LA(2)==S...5926. declaration_specifiers();
5927. {
5928. boolean synPredMatched270 = false;
5929. if (((_tokenSet_45.member(LA(1))) && (_tokenSet_49.member(LA(2))))) {
5930. int _m270 = mark();
5931. synPredMatched270 = true;
5932. inputState.guessing++;
5933. try {
5934. {
5935. declarator();
5936. }
5937. }
5938. catch (RecognitionException pe) {
5939. synPredMatched270 = false;
5940. }
5941. rewind(_m270);
5942. inputState.guessing--;
5943. }
5944. if ( synPredMatched270 ) {
5945. declarator();
5946. }
5947. else if ((_tokenSet_50.member(LA(1))) && (_tokenSet_51.member(LA(2)))) {
5948. abstract_declarator();
5949. }
5950. else {
5951. throw new NoViableAltException(LT(1), getFilename());
5952. }
5953.
5954. }
5955. }
5956. else {
5957. boolean synPredMatched272 = false;
5958. if (((_tokenSet_45.member(LA(1))) && (_tokenSet_49.member(LA(2))))) {
5959. int _m272 = mark();
5960. synPredMatched272 = true;
5961. inputState.guessing++;
5962. try {
5963. {
5964. declarator();
5965. }
5966. }
5967. catch (RecognitionException pe) {
5968. synPredMatched272 = false;
5969. }
5970. rewind(_m272);
5971. inputState.guessing--;
5972. }
5973. if ( synPredMatched272 ) {
5974. declarator();
5975. }
5976. else if ((LA(1)==ELLIPSIS)) {
5977. match(ELLIPSIS);
5978. }
5979. else {
5980. throw new NoViableAltException(LT(1), getFilename());
5981. }
5982. }
5983. }
5984. {
5985. switch ( LA(1)) {
5986. case ASSIGNEQUAL:
5987. {
5988. match(ASSIGNEQUAL);
5989. remainder_expression();
5990. break;
5991. }
5992. case GREATERTHAN:
5993. case COMMA:
5994. case RPAREN:
5995. case ELLIPSIS:
5996. {
5997. break;
5998. }
5999. default:
6000. {
6001. throw new NoViableAltException(LT(1), getFilename());
6002. }
6003. }
6004. }
6005. if ( inputState.guessing==0 ) {
6006. m.endParameterDeclaration();
6007. }
6008. }
6009.
6010. public final void abstract_declarator() throws RecognitionException, TokenStreamException {
6011.
6012.
6013. switch ( LA(1)) {
6014. case ID:
6015. case LITERAL__stdcall:
6016. case LITERAL___stdcall:
6017. case STAR:
6018. case AMPERSAND:
6019. case SCOPE:
6020. case LITERAL__cdecl:
6021. case LITERAL___cdecl:
6022. case LITERAL__near:
6023. case LITERAL___near:
6024. case LITERAL__far:
6025. case LITERAL___far:
6026. case LITERAL___interrupt:
6027. case LITERAL_pascal:
6028. case LITERAL__pascal:
6029. case LITERAL___pascal:
6030. {
6031. ptr_operator();
6032. abstract_declarator();
6033. break;
6034. }
6035. case LPAREN:
6036. {
6037. match(LPAREN);
6038. abstract_declarator();
6039. match(RPAREN);
6040. {
6041. int _cnt277=0;
6042. _loop277:
6043. do {
6044. if ((LA(1)==LPAREN||LA(1)==LSQUARE)) {
6045. abstract_declarator_suffix();
6046. }
6047. else {
6048. if ( _cnt277>=1 ) { break _loop277; } else {throw new NoViableAltException(LT(1), getFilename()...6049. }
6050.
6051. _cnt277++;
6052. } while (true);
6053. }
6054. break;
6055. }
6056. case LSQUARE:
6057. {
6058. {
6059. int _cnt280=0;
6060. _loop280:
6061. do {
6062. if ((LA(1)==LSQUARE)) {
6063. match(LSQUARE);
6064. {
6065. switch ( LA(1)) {
6066. case ID:
6067. case StringLiteral:
6068. case LITERAL__declspec:
6069. case LITERAL___declspec:
6070. case LPAREN:
6071. case LITERAL_const_cast:
6072. case LITERAL_char:
6073. case LITERAL_wchar_t:
6074. case LITERAL_bool:
6075. case LITERAL_short:
6076. case LITERAL_int:
6077. case 44:
6078. case 45:
6079. case 46:
6080. case LITERAL_long:
6081. case LITERAL_signed:
6082. case LITERAL_unsigned:
6083. case LITERAL_float:
6084. case LITERAL_double:
6085. case LITERAL_void:
6086. case OPERATOR:
6087. case LITERAL_this:
6088. case LITERAL_true:
6089. case LITERAL_false:
6090. case OCTALINT:
6091. case STAR:
6092. case AMPERSAND:
6093. case TILDE:
6094. case PLUS:
6095. case MINUS:
6096. case PLUSPLUS:
6097. case MINUSMINUS:
6098. case LITERAL_sizeof:
6099. case SCOPE:
6100. case LITERAL_dynamic_cast:
6101. case LITERAL_static_cast:
6102. case LITERAL_reinterpret_cast:
6103. case NOT:
6104. case LITERAL_new:
6105. case LITERAL_delete:
6106. case DECIMALINT:
6107. case HEXADECIMALINT:
6108. case CharLiteral:
6109. case FLOATONE:
6110. case FLOATTWO:
6111. {
6112. constant_expression();
6113. break;
6114. }
6115. case RSQUARE:
6116. {
6117. break;
6118. }
6119. default:
6120. {
6121. throw new NoViableAltException(LT(1), getFilename());
6122. }
6123. }
6124. }
6125. match(RSQUARE);
6126. }
6127. else {
6128. if ( _cnt280>=1 ) { break _loop280; } else {throw new NoViableAltException(LT(1), getFilename()...6129. }
6130.
6131. _cnt280++;
6132. } while (true);
6133. }
6134. break;
6135. }
6136. case GREATERTHAN:
6137. case ASSIGNEQUAL:
6138. case COMMA:
6139. case RPAREN:
6140. case ELLIPSIS:
6141. {
6142. break;
6143. }
6144. default:
6145. {
6146. throw new NoViableAltException(LT(1), getFilename());
6147. }
6148. }
6149. }
6150.
6151. public final void type_name() throws RecognitionException, TokenStreamException {
6152.
6153.
6154. declaration_specifiers();
6155. abstract_declarator();
6156. }
6157.
6158. public final void abstract_declarator_suffix() throws RecognitionException, TokenStreamException {
...6159.
6160.
6161. switch ( LA(1)) {
6162. case LSQUARE:
6163. {
6164. match(LSQUARE);
6165. {
6166. switch ( LA(1)) {
6167. case ID:
6168. case StringLiteral:
6169. case LITERAL__declspec:
6170. case LITERAL___declspec:
6171. case LPAREN:
6172. case LITERAL_const_cast:
6173. case LITERAL_char:
6174. case LITERAL_wchar_t:
6175. case LITERAL_bool:
6176. case LITERAL_short:
6177. case LITERAL_int:
6178. case 44:
6179. case 45:
6180. case 46:
6181. case LITERAL_long:
6182. case LITERAL_signed:
6183. case LITERAL_unsigned:
6184. case LITERAL_float:
6185. case LITERAL_double:
6186. case LITERAL_void:
6187. case OPERATOR:
6188. case LITERAL_this:
6189. case LITERAL_true:
6190. case LITERAL_false:
6191. case OCTALINT:
6192. case STAR:
6193. case AMPERSAND:
6194. case TILDE:
6195. case PLUS:
6196. case MINUS:
6197. case PLUSPLUS:
6198. case MINUSMINUS:
6199. case LITERAL_sizeof:
6200. case SCOPE:
6201. case LITERAL_dynamic_cast:
6202. case LITERAL_static_cast:
6203. case LITERAL_reinterpret_cast:
6204. case NOT:
6205. case LITERAL_new:
6206. case LITERAL_delete:
6207. case DECIMALINT:
6208. case HEXADECIMALINT:
6209. case CharLiteral:
6210. case FLOATONE:
6211. case FLOATTWO:
6212. {
6213. constant_expression();
6214. break;
6215. }
6216. case RSQUARE:
6217. {
6218. break;
6219. }
6220. default:
6221. {
6222. throw new NoViableAltException(LT(1), getFilename());
6223. }
6224. }
6225. }
6226. match(RSQUARE);
6227. break;
6228. }
6229. case LPAREN:
6230. {
6231. match(LPAREN);
6232. {
6233. switch ( LA(1)) {
6234. case LITERAL_typedef:
6235. case LITERAL_enum:
6236. case ID:
6237. case LITERAL_inline:
6238. case LITERAL_extern:
6239. case LITERAL__inline:
6240. case LITERAL___inline:
6241. case LITERAL_virtual:
6242. case LITERAL_explicit:
6243. case LITERAL_friend:
6244. case LITERAL__stdcall:
6245. case LITERAL___stdcall:
6246. case LITERAL__declspec:
6247. case LITERAL___declspec:
6248. case LPAREN:
6249. case LITERAL_typename:
6250. case LITERAL_auto:
6251. case LITERAL_register:
6252. case LITERAL_static:
6253. case LITERAL_mutable:
6254. case LITERAL_const:
6255. case LITERAL_const_cast:
6256. case LITERAL_volatile:
6257. case LITERAL_char:
6258. case LITERAL_wchar_t:
6259. case LITERAL_bool:
6260. case LITERAL_short:
6261. case LITERAL_int:
6262. case 44:
6263. case 45:
6264. case 46:
6265. case LITERAL_long:
6266. case LITERAL_signed:
6267. case LITERAL_unsigned:
6268. case LITERAL_float:
6269. case LITERAL_double:
6270. case LITERAL_void:
6271. case LITERAL_class:
6272. case LITERAL_struct:
6273. case LITERAL_union:
6274. case OPERATOR:
6275. case LITERAL_this:
6276. case LITERAL_true:
6277. case LITERAL_false:
6278. case STAR:
6279. case AMPERSAND:
6280. case TILDE:
6281. case ELLIPSIS:
6282. case SCOPE:
6283. case LITERAL__cdecl:
6284. case LITERAL___cdecl:
6285. case LITERAL__near:
6286. case LITERAL___near:
6287. case LITERAL__far:
6288. case LITERAL___far:
6289. case LITERAL___interrupt:
6290. case LITERAL_pascal:
6291. case LITERAL__pascal:
6292. case LITERAL___pascal:
6293. {
6294. parameter_list();
6295. break;
6296. }
6297. case RPAREN:
6298. {
6299. break;
6300. }
6301. default:
6302. {
6303. throw new NoViableAltException(LT(1), getFilename());
6304. }
6305. }
6306. }
6307. match(RPAREN);
6308. cv_qualifier_seq();
6309. {
6310. switch ( LA(1)) {
6311. case LITERAL_throw:
6312. {
6313. exception_specification();
6314. break;
6315. }
6316. case GREATERTHAN:
6317. case ASSIGNEQUAL:
6318. case COMMA:
6319. case LPAREN:
6320. case RPAREN:
6321. case LSQUARE:
6322. case ELLIPSIS:
6323. {
6324. break;
6325. }
6326. default:
6327. {
6328. throw new NoViableAltException(LT(1), getFilename());
6329. }
6330. }
6331. }
6332. break;
6333. }
6334. default:
6335. {
6336. throw new NoViableAltException(LT(1), getFilename());
6337. }
6338. }
6339. }
6340.
6341. public final void template_parameter() throws RecognitionException, TokenStreamException {
6342.
6343. Token id = null;
6344.
6345. {
6346. if ((LA(1)==LITERAL_typename||LA(1)==LITERAL_class) && (_tokenSet_52.member(LA(2)))) {
6347. {
6348. switch ( LA(1)) {
6349. case LITERAL_class:
6350. {
6351. match(LITERAL_class);
6352. break;
6353. }
6354. case LITERAL_typename:
6355. {
6356. match(LITERAL_typename);
6357. break;
6358. }
6359. default:
6360. {
6361. throw new NoViableAltException(LT(1), getFilename());
6362. }
6363. }
6364. }
6365. {
6366. switch ( LA(1)) {
6367. case ID:
6368. {
6369. id = LT(1);
6370. match(ID);
6371. {
6372. switch ( LA(1)) {
6373. case ASSIGNEQUAL:
6374. {
6375. match(ASSIGNEQUAL);
6376. assigned_type_name();
6377. break;
6378. }
6379. case GREATERTHAN:
6380. case COMMA:
6381. {
6382. break;
6383. }
6384. default:
6385. {
6386. throw new NoViableAltException(LT(1), getFilename());
6387. }
6388. }
6389. }
6390. break;
6391. }
6392. case GREATERTHAN:
6393. case COMMA:
6394. {
6395. break;
6396. }
6397. default:
6398. {
6399. throw new NoViableAltException(LT(1), getFilename());
6400. }
6401. }
6402. }
6403. if ( inputState.guessing==0 ) {
6404. if(!symbols.containsKey(id.getText()))
6405. symbols.put(id.getText(),CPPvariables.OT_TYPE_DEF);
6406.
6407. }
6408. }
6409. else if ((_tokenSet_53.member(LA(1))) && (_tokenSet_10.member(LA(2)))) {
6410. parameter_declaration();
6411. }
6412. else {
6413. throw new NoViableAltException(LT(1), getFilename());
6414. }
6415.
6416. }
6417. }
6418.
6419. public final void assigned_type_name() throws RecognitionException, TokenStreamException {
6420.
6421. String s="";
6422.
6423. {
6424. if ((LA(1)==ID||LA(1)==SCOPE) && (_tokenSet_54.member(LA(2)))) {
6425. s=qualified_type();
6426. abstract_declarator();
6427. }
6428. else if ((_tokenSet_55.member(LA(1))) && (_tokenSet_56.member(LA(2)))) {
6429. simple_type_specifier();
6430. abstract_declarator();
6431. }
6432. else {
6433. throw new NoViableAltException(LT(1), getFilename());
6434. }
6435.
6436. }
6437. }
6438.
6439. public final void template_id() throws RecognitionException, TokenStreamException {
6440.
6441.
6442. match(ID);
6443. match(LESSTHAN);
6444. template_argument_list();
6445. match(GREATERTHAN);
6446. }
6447.
6448. public final void template_argument() throws RecognitionException, TokenStreamException {
6449.
6450. java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone(); auxBitSet.or(CPPvariabl...6451.
6452. if (((_tokenSet_11.member(LA(1))) && (_tokenSet_57.member(LA(2))))&&(( !(LA(1)==SCOPE||LA(1)==ID) ...6453. type_name();
6454. }
6455. else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_58.member(LA(2)))) {
6456. shift_expression();
6457. }
6458. else {
6459. throw new NoViableAltException(LT(1), getFilename());
6460. }
6461.
6462. }
6463.
6464. public final void shift_expression() throws RecognitionException, TokenStreamException {
6465.
6466.
6467. additive_expression();
6468. {
6469. _loop385:
6470. do {
6471. if ((LA(1)==SHIFTLEFT||LA(1)==SHIFTRIGHT)) {
6472. {
6473. switch ( LA(1)) {
6474. case SHIFTLEFT:
6475. {
6476. match(SHIFTLEFT);
6477. break;
6478. }
6479. case SHIFTRIGHT:
6480. {
6481. match(SHIFTRIGHT);
6482. break;
6483. }
6484. default:
6485. {
6486. throw new NoViableAltException(LT(1), getFilename());
6487. }
6488. }
6489. }
6490. additive_expression();
6491. }
6492. else {
6493. break _loop385;
6494. }
6495.
6496. } while (true);
6497. }
6498. }
6499.
6500. public final void statement_list() throws RecognitionException, TokenStreamException {
6501.
6502.
6503. {
6504. int _cnt308=0;
6505. _loop308:
6506. do {
6507. if ((_tokenSet_59.member(LA(1)))) {
6508. statement();
6509. }
6510. else {
6511. if ( _cnt308>=1 ) { break _loop308; } else {throw new NoViableAltException(LT(1), getFilename())...6512. }
6513.
6514. _cnt308++;
6515. } while (true);
6516. }
6517. }
6518.
6519. public final void statement() throws RecognitionException, TokenStreamException {
6520.
6521.
6522. {
6523. switch ( LA(1)) {
6524. case LITERAL_case:
6525. {
6526. case_statement();
6527. break;
6528. }
6529. case LITERAL_default:
6530. {
6531. default_statement();
6532. break;
6533. }
6534. case LCURLY:
6535. {
6536. compound_statement();
6537. break;
6538. }
6539. case LITERAL_if:
6540. case LITERAL_switch:
6541. {
6542. selection_statement();
6543. break;
6544. }
6545. case LITERAL_while:
6546. case LITERAL_do:
6547. case LITERAL_for:
6548. {
6549. iteration_statement();
6550. break;
6551. }
6552. case LITERAL_goto:
6553. case LITERAL_continue:
6554. case LITERAL_break:
6555. case LITERAL_return:
6556. {
6557. jump_statement();
6558. break;
6559. }
6560. case SEMICOLON:
6561. {
6562. match(SEMICOLON);
6563. break;
6564. }
6565. case LITERAL_try:
6566. {
6567. try_block();
6568. break;
6569. }
6570. case LITERAL_throw:
6571. {
6572. throw_statement();
6573. break;
6574. }
6575. case LITERAL__asm:
6576. case LITERAL___asm:
6577. {
6578. asm_block();
6579. break;
6580. }
6581. default:
6582. boolean synPredMatched312 = false;
6583. if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
6584. int _m312 = mark();
6585. synPredMatched312 = true;
6586. inputState.guessing++;
6587. try {
6588. {
6589. declaration();
6590. }
6591. }
6592. catch (RecognitionException pe) {
6593. synPredMatched312 = false;
6594. }
6595. rewind(_m312);
6596. inputState.guessing--;
6597. }
6598. if ( synPredMatched312 ) {
6599. declaration();
6600. }
6601. else if ((LA(1)==ID) && (LA(2)==COLON)) {
6602. labeled_statement();
6603. }
6604. else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_60.member(LA(2)))) {
6605. expression();
6606. match(SEMICOLON);
6607. }
6608. else {
6609. throw new NoViableAltException(LT(1), getFilename());
6610. }
6611. }
6612. }
6613. }
6614.
6615. public final void labeled_statement() throws RecognitionException, TokenStreamException {
6616.
6617.
6618. match(ID);
6619. match(COLON);
6620. statement();
6621. }
6622.
6623. public final void case_statement() throws RecognitionException, TokenStreamException {
6624.
6625.
6626. match(LITERAL_case);
6627. constant_expression();
6628. match(COLON);
6629. statement();
6630. }
6631.
6632. public final void default_statement() throws RecognitionException, TokenStreamException {
6633.
6634.
6635. match(LITERAL_default);
6636. match(COLON);
6637. statement();
6638. }
6639.
6640. public final void expression() throws RecognitionException, TokenStreamException {
6641.
6642.
6643. assignment_expression();
6644. {
6645. _loop347:
6646. do {
6647. if ((LA(1)==COMMA)) {
6648. match(COMMA);
6649. assignment_expression();
6650. }
6651. else {
6652. break _loop347;
6653. }
6654.
6655. } while (true);
6656. }
6657. }
6658.
6659. public final void selection_statement() throws RecognitionException, TokenStreamException {
6660.
6661.
6662. switch ( LA(1)) {
6663. case LITERAL_if:
6664. {
6665. match(LITERAL_if);
6666. match(LPAREN);
6667. expression();
6668. match(RPAREN);
6669. statement();
6670. {
6671. if ((LA(1)==LITERAL_else) && (_tokenSet_59.member(LA(2)))) {
6672. match(LITERAL_else);
6673. statement();
6674. }
6675. else if ((_tokenSet_61.member(LA(1))) && (_tokenSet_62.member(LA(2)))) {
6676. }
6677. else {
6678. throw new NoViableAltException(LT(1), getFilename());
6679. }
6680.
6681. }
6682. break;
6683. }
6684. case LITERAL_switch:
6685. {
6686. match(LITERAL_switch);
6687. match(LPAREN);
6688. expression();
6689. match(RPAREN);
6690. statement();
6691. break;
6692. }
6693. default:
6694. {
6695. throw new NoViableAltException(LT(1), getFilename());
6696. }
6697. }
6698. }
6699.
6700. public final void iteration_statement() throws RecognitionException, TokenStreamException {
6701.
6702.
6703. switch ( LA(1)) {
6704. case LITERAL_while:
6705. {
6706. match(LITERAL_while);
6707. match(LPAREN);
6708. expression();
6709. match(RPAREN);
6710. statement();
6711. break;
6712. }
6713. case LITERAL_do:
6714. {
6715. match(LITERAL_do);
6716. statement();
6717. match(LITERAL_while);
6718. match(LPAREN);
6719. expression();
6720. match(RPAREN);
6721. match(SEMICOLON);
6722. break;
6723. }
6724. case LITERAL_for:
6725. {
6726. match(LITERAL_for);
6727. match(LPAREN);
6728. {
6729. boolean synPredMatched323 = false;
6730. if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
6731. int _m323 = mark();
6732. synPredMatched323 = true;
6733. inputState.guessing++;
6734. try {
6735. {
6736. declaration();
6737. }
6738. }
6739. catch (RecognitionException pe) {
6740. synPredMatched323 = false;
6741. }
6742. rewind(_m323);
6743. inputState.guessing--;
6744. }
6745. if ( synPredMatched323 ) {
6746. declaration();
6747. }
6748. else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_60.member(LA(2)))) {
6749. expression();
6750. match(SEMICOLON);
6751. }
6752. else if ((LA(1)==SEMICOLON)) {
6753. match(SEMICOLON);
6754. }
6755. else {
6756. throw new NoViableAltException(LT(1), getFilename());
6757. }
6758.
6759. }
6760. {
6761. switch ( LA(1)) {
6762. case ID:
6763. case StringLiteral:
6764. case LITERAL__declspec:
6765. case LITERAL___declspec:
6766. case LPAREN:
6767. case LITERAL_const_cast:
6768. case LITERAL_char:
6769. case LITERAL_wchar_t:
6770. case LITERAL_bool:
6771. case LITERAL_short:
6772. case LITERAL_int:
6773. case 44:
6774. case 45:
6775. case 46:
6776. case LITERAL_long:
6777. case LITERAL_signed:
6778. case LITERAL_unsigned:
6779. case LITERAL_float:
6780. case LITERAL_double:
6781. case LITERAL_void:
6782. case OPERATOR:
6783. case LITERAL_this:
6784. case LITERAL_true:
6785. case LITERAL_false:
6786. case OCTALINT:
6787. case STAR:
6788. case AMPERSAND:
6789. case TILDE:
6790. case PLUS:
6791. case MINUS:
6792. case PLUSPLUS:
6793. case MINUSMINUS:
6794. case LITERAL_sizeof:
6795. case SCOPE:
6796. case LITERAL_dynamic_cast:
6797. case LITERAL_static_cast:
6798. case LITERAL_reinterpret_cast:
6799. case NOT:
6800. case LITERAL_new:
6801. case LITERAL_delete:
6802. case DECIMALINT:
6803. case HEXADECIMALINT:
6804. case CharLiteral:
6805. case FLOATONE:
6806. case FLOATTWO:
6807. {
6808. expression();
6809. break;
6810. }
6811. case SEMICOLON:
6812. {
6813. break;
6814. }
6815. default:
6816. {
6817. throw new NoViableAltException(LT(1), getFilename());
6818. }
6819. }
6820. }
6821. match(SEMICOLON);
6822. {
6823. switch ( LA(1)) {
6824. case ID:
6825. case StringLiteral:
6826. case LITERAL__declspec:
6827. case LITERAL___declspec:
6828. case LPAREN:
6829. case LITERAL_const_cast:
6830. case LITERAL_char:
6831. case LITERAL_wchar_t:
6832. case LITERAL_bool:
6833. case LITERAL_short:
6834. case LITERAL_int:
6835. case 44:
6836. case 45:
6837. case 46:
6838. case LITERAL_long:
6839. case LITERAL_signed:
6840. case LITERAL_unsigned:
6841. case LITERAL_float:
6842. case LITERAL_double:
6843. case LITERAL_void:
6844. case OPERATOR:
6845. case LITERAL_this:
6846. case LITERAL_true:
6847. case LITERAL_false:
6848. case OCTALINT:
6849. case STAR:
6850. case AMPERSAND:
6851. case TILDE:
6852. case PLUS:
6853. case MINUS:
6854. case PLUSPLUS:
6855. case MINUSMINUS:
6856. case LITERAL_sizeof:
6857. case SCOPE:
6858. case LITERAL_dynamic_cast:
6859. case LITERAL_static_cast:
6860. case LITERAL_reinterpret_cast:
6861. case NOT:
6862. case LITERAL_new:
6863. case LITERAL_delete:
6864. case DECIMALINT:
6865. case HEXADECIMALINT:
6866. case CharLiteral:
6867. case FLOATONE:
6868. case FLOATTWO:
6869. {
6870. expression();
6871. break;
6872. }
6873. case RPAREN:
6874. {
6875. break;
6876. }
6877. default:
6878. {
6879. throw new NoViableAltException(LT(1), getFilename());
6880. }
6881. }
6882. }
6883. match(RPAREN);
6884. statement();
6885. break;
6886. }
6887. default:
6888. {
6889. throw new NoViableAltException(LT(1), getFilename());
6890. }
6891. }
6892. }
6893.
6894. public final void jump_statement() throws RecognitionException, TokenStreamException {
6895.
6896.
6897. {
6898. switch ( LA(1)) {
6899. case LITERAL_goto:
6900. {
6901. match(LITERAL_goto);
6902. match(ID);
6903. match(SEMICOLON);
6904. break;
6905. }
6906. case LITERAL_continue:
6907. {
6908. match(LITERAL_continue);
6909. match(SEMICOLON);
6910. break;
6911. }
6912. case LITERAL_break:
6913. {
6914. match(LITERAL_break);
6915. match(SEMICOLON);
6916. break;
6917. }
6918. case LITERAL_return:
6919. {
6920. match(LITERAL_return);
6921. {
6922. boolean synPredMatched330 = false;
6923. if (((LA(1)==LPAREN) && (LA(2)==ID))) {
6924. int _m330 = mark();
6925. synPredMatched330 = true;
6926. inputState.guessing++;
6927. try {
6928. {
6929. match(LPAREN);
6930. if (!((qualifiedItemIsOneOf(CPPvariables.QI_TYPE,0) )))
6931. throw new SemanticException("(qualifiedItemIsOneOf(CPPvariables.QI_TYPE,0) )");
6932. match(ID);
6933. match(RPAREN);
6934. }
6935. }
6936. catch (RecognitionException pe) {
6937. synPredMatched330 = false;
6938. }
6939. rewind(_m330);
6940. inputState.guessing--;
6941. }
6942. if ( synPredMatched330 ) {
6943. match(LPAREN);
6944. match(ID);
6945. match(RPAREN);
6946. {
6947. switch ( LA(1)) {
6948. case ID:
6949. case StringLiteral:
6950. case LITERAL__declspec:
6951. case LITERAL___declspec:
6952. case LPAREN:
6953. case LITERAL_const_cast:
6954. case LITERAL_char:
6955. case LITERAL_wchar_t:
6956. case LITERAL_bool:
6957. case LITERAL_short:
6958. case LITERAL_int:
6959. case 44:
6960. case 45:
6961. case 46:
6962. case LITERAL_long:
6963. case LITERAL_signed:
6964. case LITERAL_unsigned:
6965. case LITERAL_float:
6966. case LITERAL_double:
6967. case LITERAL_void:
6968. case OPERATOR:
6969. case LITERAL_this:
6970. case LITERAL_true:
6971. case LITERAL_false:
6972. case OCTALINT:
6973. case STAR:
6974. case AMPERSAND:
6975. case TILDE:
6976. case PLUS:
6977. case MINUS:
6978. case PLUSPLUS:
6979. case MINUSMINUS:
6980. case LITERAL_sizeof:
6981. case SCOPE:
6982. case LITERAL_dynamic_cast:
6983. case LITERAL_static_cast:
6984. case LITERAL_reinterpret_cast:
6985. case NOT:
6986. case LITERAL_new:
6987. case LITERAL_delete:
6988. case DECIMALINT:
6989. case HEXADECIMALINT:
6990. case CharLiteral:
6991. case FLOATONE:
6992. case FLOATTWO:
6993. {
6994. expression();
6995. break;
6996. }
6997. case SEMICOLON:
6998. {
6999. break;
7000. }
7001. default:
7002. {
7003. throw new NoViableAltException(LT(1), getFilename());
7004. }
7005. }
7006. }
7007. }
7008. else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_60.member(LA(2)))) {
7009. expression();
7010. }
7011. else if ((LA(1)==SEMICOLON)) {
7012. }
7013. else {
7014. throw new NoViableAltException(LT(1), getFilename());
7015. }
7016.
7017. }
7018. match(SEMICOLON);
7019. break;
7020. }
7021. default:
7022. {
7023. throw new NoViableAltException(LT(1), getFilename());
7024. }
7025. }
7026. }
7027. }
7028.
7029. public final void try_block() throws RecognitionException, TokenStreamException {
7030.
7031.
7032. match(LITERAL_try);
7033. compound_statement();
7034. {
7035. _loop334:
7036. do {
7037. if ((LA(1)==LITERAL_catch)) {
7038. handler();
7039. }
7040. else {
7041. break _loop334;
7042. }
7043.
7044. } while (true);
7045. }
7046. }
7047.
7048. public final void throw_statement() throws RecognitionException, TokenStreamException {
7049.
7050.
7051. match(LITERAL_throw);
7052. {
7053. switch ( LA(1)) {
7054. case ID:
7055. case StringLiteral:
7056. case LITERAL__declspec:
7057. case LITERAL___declspec:
7058. case LPAREN:
7059. case LITERAL_const_cast:
7060. case LITERAL_char:
7061. case LITERAL_wchar_t:
7062. case LITERAL_bool:
7063. case LITERAL_short:
7064. case LITERAL_int:
7065. case 44:
7066. case 45:
7067. case 46:
7068. case LITERAL_long:
7069. case LITERAL_signed:
7070. case LITERAL_unsigned:
7071. case LITERAL_float:
7072. case LITERAL_double:
7073. case LITERAL_void:
7074. case OPERATOR:
7075. case LITERAL_this:
7076. case LITERAL_true:
7077. case LITERAL_false:
7078. case OCTALINT:
7079. case STAR:
7080. case AMPERSAND:
7081. case TILDE:
7082. case PLUS:
7083. case MINUS:
7084. case PLUSPLUS:
7085. case MINUSMINUS:
7086. case LITERAL_sizeof:
7087. case SCOPE:
7088. case LITERAL_dynamic_cast:
7089. case LITERAL_static_cast:
7090. case LITERAL_reinterpret_cast:
7091. case NOT:
7092. case LITERAL_new:
7093. case LITERAL_delete:
7094. case DECIMALINT:
7095. case HEXADECIMALINT:
7096. case CharLiteral:
7097. case FLOATONE:
7098. case FLOATTWO:
7099. {
7100. assignment_expression();
7101. break;
7102. }
7103. case SEMICOLON:
7104. {
7105. break;
7106. }
7107. default:
7108. {
7109. throw new NoViableAltException(LT(1), getFilename());
7110. }
7111. }
7112. }
7113. match(SEMICOLON);
7114. }
7115.
7116. public final void asm_block() throws RecognitionException, TokenStreamException {
7117.
7118.
7119. {
7120. switch ( LA(1)) {
7121. case LITERAL__asm:
7122. {
7123. match(LITERAL__asm);
7124. break;
7125. }
7126. case LITERAL___asm:
7127. {
7128. match(LITERAL___asm);
7129. break;
7130. }
7131. default:
7132. {
7133. throw new NoViableAltException(LT(1), getFilename());
7134. }
7135. }
7136. }
7137. match(LCURLY);
7138. {
7139. _loop344:
7140. do {
7141. if ((_tokenSet_63.member(LA(1)))) {
7142. matchNot(RCURLY);
7143. }
7144. else {
7145. break _loop344;
7146. }
7147.
7148. } while (true);
7149. }
7150. match(RCURLY);
7151. }
7152.
7153. public final void handler() throws RecognitionException, TokenStreamException {
7154.
7155.
7156. match(LITERAL_catch);
7157. match(LPAREN);
7158. exception_declaration();
7159. match(RPAREN);
7160. compound_statement();
7161. }
7162.
7163. public final void exception_declaration() throws RecognitionException, TokenStreamException {
7164.
7165.
7166. parameter_declaration_list();
7167. }
7168.
7169. public final void assignment_expression() throws RecognitionException, TokenStreamException {
7170.
7171.
7172. conditional_expression();
7173. {
7174. switch ( LA(1)) {
7175. case ASSIGNEQUAL:
7176. case TIMESEQUAL:
7177. case DIVIDEEQUAL:
7178. case MINUSEQUAL:
7179. case PLUSEQUAL:
7180. case MODEQUAL:
7181. case SHIFTLEFTEQUAL:
7182. case SHIFTRIGHTEQUAL:
7183. case BITWISEANDEQUAL:
7184. case BITWISEXOREQUAL:
7185. case BITWISEOREQUAL:
7186. {
7187. {
7188. switch ( LA(1)) {
7189. case ASSIGNEQUAL:
7190. {
7191. match(ASSIGNEQUAL);
7192. break;
7193. }
7194. case TIMESEQUAL:
7195. {
7196. match(TIMESEQUAL);
7197. break;
7198. }
7199. case DIVIDEEQUAL:
7200. {
7201. match(DIVIDEEQUAL);
7202. break;
7203. }
7204. case MINUSEQUAL:
7205. {
7206. match(MINUSEQUAL);
7207. break;
7208. }
7209. case PLUSEQUAL:
7210. {
7211. match(PLUSEQUAL);
7212. break;
7213. }
7214. case MODEQUAL:
7215. {
7216. match(MODEQUAL);
7217. break;
7218. }
7219. case SHIFTLEFTEQUAL:
7220. {
7221. match(SHIFTLEFTEQUAL);
7222. break;
7223. }
7224. case SHIFTRIGHTEQUAL:
7225. {
7226. match(SHIFTRIGHTEQUAL);
7227. break;
7228. }
7229. case BITWISEANDEQUAL:
7230. {
7231. match(BITWISEANDEQUAL);
7232. break;
7233. }
7234. case BITWISEXOREQUAL:
7235. {
7236. match(BITWISEXOREQUAL);
7237. break;
7238. }
7239. case BITWISEOREQUAL:
7240. {
7241. match(BITWISEOREQUAL);
7242. break;
7243. }
7244. default:
7245. {
7246. throw new NoViableAltException(LT(1), getFilename());
7247. }
7248. }
7249. }
7250. remainder_expression();
7251. break;
7252. }
7253. case GREATERTHAN:
7254. case SEMICOLON:
7255. case RCURLY:
7256. case COLON:
7257. case COMMA:
7258. case RPAREN:
7259. case RSQUARE:
7260. case ELLIPSIS:
7261. {
7262. break;
7263. }
7264. default:
7265. {
7266. throw new NoViableAltException(LT(1), getFilename());
7267. }
7268. }
7269. }
7270. }
7271.
7272. public final void conditional_expression() throws RecognitionException, TokenStreamException {
7273.
7274.
7275. logical_or_expression();
7276. {
7277. switch ( LA(1)) {
7278. case QUESTIONMARK:
7279. {
7280. match(QUESTIONMARK);
7281. expression();
7282. match(COLON);
7283. conditional_expression();
7284. break;
7285. }
7286. case GREATERTHAN:
7287. case SEMICOLON:
7288. case RCURLY:
7289. case ASSIGNEQUAL:
7290. case COLON:
7291. case COMMA:
7292. case RPAREN:
7293. case RSQUARE:
7294. case ELLIPSIS:
7295. case TIMESEQUAL:
7296. case DIVIDEEQUAL:
7297. case MINUSEQUAL:
7298. case PLUSEQUAL:
7299. case MODEQUAL:
7300. case SHIFTLEFTEQUAL:
7301. case SHIFTRIGHTEQUAL:
7302. case BITWISEANDEQUAL:
7303. case BITWISEXOREQUAL:
7304. case BITWISEOREQUAL:
7305. {
7306. break;
7307. }
7308. default:
7309. {
7310. throw new NoViableAltException(LT(1), getFilename());
7311. }
7312. }
7313. }
7314. }
7315.
7316. public final void logical_or_expression() throws RecognitionException, TokenStreamException {
7317.
7318.
7319. logical_and_expression();
7320. {
7321. _loop361:
7322. do {
7323. if ((LA(1)==OR)) {
7324. match(OR);
7325. logical_and_expression();
7326. }
7327. else {
7328. break _loop361;
7329. }
7330.
7331. } while (true);
7332. }
7333. }
7334.
7335. public final void logical_and_expression() throws RecognitionException, TokenStreamException {
7336.
7337.
7338. inclusive_or_expression();
7339. {
7340. _loop364:
7341. do {
7342. if ((LA(1)==AND)) {
7343. match(AND);
7344. inclusive_or_expression();
7345. }
7346. else {
7347. break _loop364;
7348. }
7349.
7350. } while (true);
7351. }
7352. }
7353.
7354. public final void inclusive_or_expression() throws RecognitionException, TokenStreamException {
7355.
7356.
7357. exclusive_or_expression();
7358. {
7359. _loop367:
7360. do {
7361. if ((LA(1)==BITWISEOR)) {
7362. match(BITWISEOR);
7363. exclusive_or_expression();
7364. }
7365. else {
7366. break _loop367;
7367. }
7368.
7369. } while (true);
7370. }
7371. }
7372.
7373. public final void exclusive_or_expression() throws RecognitionException, TokenStreamException {
7374.
7375.
7376. and_expression();
7377. {
7378. _loop370:
7379. do {
7380. if ((LA(1)==BITWISEXOR)) {
7381. match(BITWISEXOR);
7382. and_expression();
7383. }
7384. else {
7385. break _loop370;
7386. }
7387.
7388. } while (true);
7389. }
7390. }
7391.
7392. public final void and_expression() throws RecognitionException, TokenStreamException {
7393.
7394.
7395. equality_expression();
7396. {
7397. _loop373:
7398. do {
7399. if ((LA(1)==AMPERSAND)) {
7400. match(AMPERSAND);
7401. equality_expression();
7402. }
7403. else {
7404. break _loop373;
7405. }
7406.
7407. } while (true);
7408. }
7409. }
7410.
7411. public final void equality_expression() throws RecognitionException, TokenStreamException {
7412.
7413.
7414. relational_expression();
7415. {
7416. _loop377:
7417. do {
7418. if ((LA(1)==NOTEQUAL||LA(1)==EQUAL)) {
7419. {
7420. switch ( LA(1)) {
7421. case NOTEQUAL:
7422. {
7423. match(NOTEQUAL);
7424. break;
7425. }
7426. case EQUAL:
7427. {
7428. match(EQUAL);
7429. break;
7430. }
7431. default:
7432. {
7433. throw new NoViableAltException(LT(1), getFilename());
7434. }
7435. }
7436. }
7437. relational_expression();
7438. }
7439. else {
7440. break _loop377;
7441. }
7442.
7443. } while (true);
7444. }
7445. }
7446.
7447. public final void relational_expression() throws RecognitionException, TokenStreamException {
7448.
7449.
7450. shift_expression();
7451. {
7452. _loop381:
7453. do {
7454. if ((_tokenSet_64.member(LA(1))) && (_tokenSet_42.member(LA(2)))) {
7455. {
7456. switch ( LA(1)) {
7457. case LESSTHAN:
7458. {
7459. match(LESSTHAN);
7460. break;
7461. }
7462. case GREATERTHAN:
7463. {
7464. match(GREATERTHAN);
7465. break;
7466. }
7467. case LESSTHANOREQUALTO:
7468. {
7469. match(LESSTHANOREQUALTO);
7470. break;
7471. }
7472. case GREATERTHANOREQUALTO:
7473. {
7474. match(GREATERTHANOREQUALTO);
7475. break;
7476. }
7477. default:
7478. {
7479. throw new NoViableAltException(LT(1), getFilename());
7480. }
7481. }
7482. }
7483. shift_expression();
7484. }
7485. else {
7486. break _loop381;
7487. }
7488.
7489. } while (true);
7490. }
7491. }
7492.
7493. public final void additive_expression() throws RecognitionException, TokenStreamException {
7494.
7495.
7496. multiplicative_expression();
7497. {
7498. _loop389:
7499. do {
7500. if ((LA(1)==PLUS||LA(1)==MINUS)) {
7501. {
7502. switch ( LA(1)) {
7503. case PLUS:
7504. {
7505. match(PLUS);
7506. break;
7507. }
7508. case MINUS:
7509. {
7510. match(MINUS);
7511. break;
7512. }
7513. default:
7514. {
7515. throw new NoViableAltException(LT(1), getFilename());
7516. }
7517. }
7518. }
7519. multiplicative_expression();
7520. }
7521. else {
7522. break _loop389;
7523. }
7524.
7525. } while (true);
7526. }
7527. }
7528.
7529. public final void multiplicative_expression() throws RecognitionException, TokenStreamException {
7530.
7531.
7532. pm_expression();
7533. {
7534. _loop393:
7535. do {
7536. if ((_tokenSet_65.member(LA(1)))) {
7537. {
7538. switch ( LA(1)) {
7539. case STAR:
7540. {
7541. match(STAR);
7542. break;
7543. }
7544. case DIVIDE:
7545. {
7546. match(DIVIDE);
7547. break;
7548. }
7549. case MOD:
7550. {
7551. match(MOD);
7552. break;
7553. }
7554. default:
7555. {
7556. throw new NoViableAltException(LT(1), getFilename());
7557. }
7558. }
7559. }
7560. pm_expression();
7561. }
7562. else {
7563. break _loop393;
7564. }
7565.
7566. } while (true);
7567. }
7568. }
7569.
7570. public final void pm_expression() throws RecognitionException, TokenStreamException {
7571.
7572.
7573. cast_expression();
7574. {
7575. _loop397:
7576. do {
7577. if ((LA(1)==DOTMBR||LA(1)==POINTERTOMBR)) {
7578. {
7579. switch ( LA(1)) {
7580. case DOTMBR:
7581. {
7582. match(DOTMBR);
7583. break;
7584. }
7585. case POINTERTOMBR:
7586. {
7587. match(POINTERTOMBR);
7588. break;
7589. }
7590. default:
7591. {
7592. throw new NoViableAltException(LT(1), getFilename());
7593. }
7594. }
7595. }
7596. cast_expression();
7597. }
7598. else {
7599. break _loop397;
7600. }
7601.
7602. } while (true);
7603. }
7604. }
7605.
7606. public final void cast_expression() throws RecognitionException, TokenStreamException {
7607.
7608.
7609. boolean synPredMatched402 = false;
7610. if (((LA(1)==LPAREN) && (_tokenSet_66.member(LA(2))))) {
7611. int _m402 = mark();
7612. synPredMatched402 = true;
7613. inputState.guessing++;
7614. try {
7615. {
7616. match(LPAREN);
7617. {
7618. switch ( LA(1)) {
7619. case LITERAL_const:
7620. case LITERAL_const_cast:
7621. case LITERAL_volatile:
7622. {
7623. type_qualifier();
7624. break;
7625. }
7626. case ID:
7627. case LITERAL__declspec:
7628. case LITERAL___declspec:
7629. case LITERAL_char:
7630. case LITERAL_wchar_t:
7631. case LITERAL_bool:
7632. case LITERAL_short:
7633. case LITERAL_int:
7634. case 44:
7635. case 45:
7636. case 46:
7637. case LITERAL_long:
7638. case LITERAL_signed:
7639. case LITERAL_unsigned:
7640. case LITERAL_float:
7641. case LITERAL_double:
7642. case LITERAL_void:
7643. case SCOPE:
7644. {
7645. break;
7646. }
7647. default:
7648. {
7649. throw new NoViableAltException(LT(1), getFilename());
7650. }
7651. }
7652. }
7653. simple_type_specifier();
7654. {
7655. switch ( LA(1)) {
7656. case ID:
7657. case LITERAL__stdcall:
7658. case LITERAL___stdcall:
7659. case STAR:
7660. case AMPERSAND:
7661. case SCOPE:
7662. case LITERAL__cdecl:
7663. case LITERAL___cdecl:
7664. case LITERAL__near:
7665. case LITERAL___near:
7666. case LITERAL__far:
7667. case LITERAL___far:
7668. case LITERAL___interrupt:
7669. case LITERAL_pascal:
7670. case LITERAL__pascal:
7671. case LITERAL___pascal:
7672. {
7673. ptr_operator();
7674. break;
7675. }
7676. case RPAREN:
7677. {
7678. break;
7679. }
7680. default:
7681. {
7682. throw new NoViableAltException(LT(1), getFilename());
7683. }
7684. }
7685. }
7686. match(RPAREN);
7687. }
7688. }
7689. catch (RecognitionException pe) {
7690. synPredMatched402 = false;
7691. }
7692. rewind(_m402);
7693. inputState.guessing--;
7694. }
7695. if ( synPredMatched402 ) {
7696. match(LPAREN);
7697. {
7698. switch ( LA(1)) {
7699. case LITERAL_const:
7700. case LITERAL_const_cast:
7701. case LITERAL_volatile:
7702. {
7703. type_qualifier();
7704. break;
7705. }
7706. case ID:
7707. case LITERAL__declspec:
7708. case LITERAL___declspec:
7709. case LITERAL_char:
7710. case LITERAL_wchar_t:
7711. case LITERAL_bool:
7712. case LITERAL_short:
7713. case LITERAL_int:
7714. case 44:
7715. case 45:
7716. case 46:
7717. case LITERAL_long:
7718. case LITERAL_signed:
7719. case LITERAL_unsigned:
7720. case LITERAL_float:
7721. case LITERAL_double:
7722. case LITERAL_void:
7723. case SCOPE:
7724. {
7725. break;
7726. }
7727. default:
7728. {
7729. throw new NoViableAltException(LT(1), getFilename());
7730. }
7731. }
7732. }
7733. simple_type_specifier();
7734. {
7735. switch ( LA(1)) {
7736. case ID:
7737. case LITERAL__stdcall:
7738. case LITERAL___stdcall:
7739. case STAR:
7740. case AMPERSAND:
7741. case SCOPE:
7742. case LITERAL__cdecl:
7743. case LITERAL___cdecl:
7744. case LITERAL__near:
7745. case LITERAL___near:
7746. case LITERAL__far:
7747. case LITERAL___far:
7748. case LITERAL___interrupt:
7749. case LITERAL_pascal:
7750. case LITERAL__pascal:
7751. case LITERAL___pascal:
7752. {
7753. ptr_operator();
7754. break;
7755. }
7756. case RPAREN:
7757. {
7758. break;
7759. }
7760. default:
7761. {
7762. throw new NoViableAltException(LT(1), getFilename());
7763. }
7764. }
7765. }
7766. match(RPAREN);
7767. cast_expression();
7768. }
7769. else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_43.member(LA(2)))) {
7770. unary_expression();
7771. }
7772. else {
7773. throw new NoViableAltException(LT(1), getFilename());
7774. }
7775.
7776. }
7777.
7778. public final void unary_expression() throws RecognitionException, TokenStreamException {
7779.
7780.
7781. {
7782. switch ( LA(1)) {
7783. case PLUSPLUS:
7784. {
7785. match(PLUSPLUS);
7786. unary_expression();
7787. break;
7788. }
7789. case MINUSMINUS:
7790. {
7791. match(MINUSMINUS);
7792. unary_expression();
7793. break;
7794. }
7795. case LITERAL_sizeof:
7796. {
7797. match(LITERAL_sizeof);
7798. {
7799. if (((LA(1)==LPAREN) && (_tokenSet_11.member(LA(2))))&&((!(((LA(1)==LPAREN&&(LA(2)==ID))))||(isTy...7800. match(LPAREN);
7801. type_name();
7802. match(RPAREN);
7803. }
7804. else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_43.member(LA(2)))) {
7805. unary_expression();
7806. }
7807. else {
7808. throw new NoViableAltException(LT(1), getFilename());
7809. }
7810.
7811. }
7812. break;
7813. }
7814. default:
7815. boolean synPredMatched408 = false;
7816. if (((_tokenSet_67.member(LA(1))) && (_tokenSet_68.member(LA(2))))) {
7817. int _m408 = mark();
7818. synPredMatched408 = true;
7819. inputState.guessing++;
7820. try {
7821. {
7822. postfix_expression();
7823. }
7824. }
7825. catch (RecognitionException pe) {
7826. synPredMatched408 = false;
7827. }
7828. rewind(_m408);
7829. inputState.guessing--;
7830. }
7831. if ( synPredMatched408 ) {
7832. postfix_expression();
7833. }
7834. else if ((_tokenSet_69.member(LA(1))) && (_tokenSet_42.member(LA(2)))) {
7835. unary_operator();
7836. cast_expression();
7837. }
7838. else if ((_tokenSet_70.member(LA(1))) && (_tokenSet_71.member(LA(2)))) {
7839. {
7840. switch ( LA(1)) {
7841. case SCOPE:
7842. {
7843. match(SCOPE);
7844. break;
7845. }
7846. case LITERAL_new:
7847. case LITERAL_delete:
7848. {
7849. break;
7850. }
7851. default:
7852. {
7853. throw new NoViableAltException(LT(1), getFilename());
7854. }
7855. }
7856. }
7857. {
7858. switch ( LA(1)) {
7859. case LITERAL_new:
7860. {
7861. new_expression();
7862. break;
7863. }
7864. case LITERAL_delete:
7865. {
7866. delete_expression();
7867. break;
7868. }
7869. default:
7870. {
7871. throw new NoViableAltException(LT(1), getFilename());
7872. }
7873. }
7874. }
7875. }
7876. else {
7877. throw new NoViableAltException(LT(1), getFilename());
7878. }
7879. }
7880. }
7881. }
7882.
7883. public final void postfix_expression() throws RecognitionException, TokenStreamException {
7884.
7885.
7886. {
7887. boolean synPredMatched415 = false;
7888. if ((((_tokenSet_55.member(LA(1))) && (_tokenSet_72.member(LA(2))))&&(!(LA(1)==LPAREN)))) {
7889. int _m415 = mark();
7890. synPredMatched415 = true;
7891. inputState.guessing++;
7892. try {
7893. {
7894. simple_type_specifier();
7895. match(LPAREN);
7896. match(RPAREN);
7897. match(LPAREN);
7898. }
7899. }
7900. catch (RecognitionException pe) {
7901. synPredMatched415 = false;
7902. }
7903. rewind(_m415);
7904. inputState.guessing--;
7905. }
7906. if ( synPredMatched415 ) {
7907. simple_type_specifier();
7908. match(LPAREN);
7909. match(RPAREN);
7910. match(LPAREN);
7911. {
7912. switch ( LA(1)) {
7913. case ID:
7914. case StringLiteral:
7915. case LITERAL__declspec:
7916. case LITERAL___declspec:
7917. case LPAREN:
7918. case LITERAL_const_cast:
7919. case LITERAL_char:
7920. case LITERAL_wchar_t:
7921. case LITERAL_bool:
7922. case LITERAL_short:
7923. case LITERAL_int:
7924. case 44:
7925. case 45:
7926. case 46:
7927. case LITERAL_long:
7928. case LITERAL_signed:
7929. case LITERAL_unsigned:
7930. case LITERAL_float:
7931. case LITERAL_double:
7932. case LITERAL_void:
7933. case OPERATOR:
7934. case LITERAL_this:
7935. case LITERAL_true:
7936. case LITERAL_false:
7937. case OCTALINT:
7938. case STAR:
7939. case AMPERSAND:
7940. case TILDE:
7941. case PLUS:
7942. case MINUS:
7943. case PLUSPLUS:
7944. case MINUSMINUS:
7945. case LITERAL_sizeof:
7946. case SCOPE:
7947. case LITERAL_dynamic_cast:
7948. case LITERAL_static_cast:
7949. case LITERAL_reinterpret_cast:
7950. case NOT:
7951. case LITERAL_new:
7952. case LITERAL_delete:
7953. case DECIMALINT:
7954. case HEXADECIMALINT:
7955. case CharLiteral:
7956. case FLOATONE:
7957. case FLOATTWO:
7958. {
7959. expression_list();
7960. break;
7961. }
7962. case RPAREN:
7963. {
7964. break;
7965. }
7966. default:
7967. {
7968. throw new NoViableAltException(LT(1), getFilename());
7969. }
7970. }
7971. }
7972. match(RPAREN);
7973. }
7974. else {
7975. boolean synPredMatched418 = false;
7976. if ((((_tokenSet_55.member(LA(1))) && (_tokenSet_72.member(LA(2))))&&(!(LA(1)==LPAREN)))) {
7977. int _m418 = mark();
7978. synPredMatched418 = true;
7979. inputState.guessing++;
7980. try {
7981. {
7982. simple_type_specifier();
7983. match(LPAREN);
7984. }
7985. }
7986. catch (RecognitionException pe) {
7987. synPredMatched418 = false;
7988. }
7989. rewind(_m418);
7990. inputState.guessing--;
7991. }
7992. if ( synPredMatched418 ) {
7993. simple_type_specifier();
7994. match(LPAREN);
7995. {
7996. switch ( LA(1)) {
7997. case ID:
7998. case StringLiteral:
7999. case LITERAL__declspec:
8000. case LITERAL___declspec:
8001. case LPAREN:
8002. case LITERAL_const_cast:
8003. case LITERAL_char:
8004. case LITERAL_wchar_t:
8005. case LITERAL_bool:
8006. case LITERAL_short:
8007. case LITERAL_int:
8008. case 44:
8009. case 45:
8010. case 46:
8011. case LITERAL_long:
8012. case LITERAL_signed:
8013. case LITERAL_unsigned:
8014. case LITERAL_float:
8015. case LITERAL_double:
8016. case LITERAL_void:
8017. case OPERATOR:
8018. case LITERAL_this:
8019. case LITERAL_true:
8020. case LITERAL_false:
8021. case OCTALINT:
8022. case STAR:
8023. case AMPERSAND:
8024. case TILDE:
8025. case PLUS:
8026. case MINUS:
8027. case PLUSPLUS:
8028. case MINUSMINUS:
8029. case LITERAL_sizeof:
8030. case SCOPE:
8031. case LITERAL_dynamic_cast:
8032. case LITERAL_static_cast:
8033. case LITERAL_reinterpret_cast:
8034. case NOT:
8035. case LITERAL_new:
8036. case LITERAL_delete:
8037. case DECIMALINT:
8038. case HEXADECIMALINT:
8039. case CharLiteral:
8040. case FLOATONE:
8041. case FLOATTWO:
8042. {
8043. expression_list();
8044. break;
8045. }
8046. case RPAREN:
8047. {
8048. break;
8049. }
8050. default:
8051. {
8052. throw new NoViableAltException(LT(1), getFilename());
8053. }
8054. }
8055. }
8056. match(RPAREN);
8057. }
8058. else if ((_tokenSet_73.member(LA(1))) && (_tokenSet_68.member(LA(2)))) {
8059. primary_expression();
8060. {
8061. _loop422:
8062. do {
8063. switch ( LA(1)) {
8064. case LSQUARE:
8065. {
8066. match(LSQUARE);
8067. expression();
8068. match(RSQUARE);
8069. break;
8070. }
8071. case LPAREN:
8072. {
8073. match(LPAREN);
8074. {
8075. switch ( LA(1)) {
8076. case ID:
8077. case StringLiteral:
8078. case LITERAL__declspec:
8079. case LITERAL___declspec:
8080. case LPAREN:
8081. case LITERAL_const_cast:
8082. case LITERAL_char:
8083. case LITERAL_wchar_t:
8084. case LITERAL_bool:
8085. case LITERAL_short:
8086. case LITERAL_int:
8087. case 44:
8088. case 45:
8089. case 46:
8090. case LITERAL_long:
8091. case LITERAL_signed:
8092. case LITERAL_unsigned:
8093. case LITERAL_float:
8094. case LITERAL_double:
8095. case LITERAL_void:
8096. case OPERATOR:
8097. case LITERAL_this:
8098. case LITERAL_true:
8099. case LITERAL_false:
8100. case OCTALINT:
8101. case STAR:
8102. case AMPERSAND:
8103. case TILDE:
8104. case PLUS:
8105. case MINUS:
8106. case PLUSPLUS:
8107. case MINUSMINUS:
8108. case LITERAL_sizeof:
8109. case SCOPE:
8110. case LITERAL_dynamic_cast:
8111. case LITERAL_static_cast:
8112. case LITERAL_reinterpret_cast:
8113. case NOT:
8114. case LITERAL_new:
8115. case LITERAL_delete:
8116. case DECIMALINT:
8117. case HEXADECIMALINT:
8118. case CharLiteral:
8119. case FLOATONE:
8120. case FLOATTWO:
8121. {
8122. expression_list();
8123. break;
8124. }
8125. case RPAREN:
8126. {
8127. break;
8128. }
8129. default:
8130. {
8131. throw new NoViableAltException(LT(1), getFilename());
8132. }
8133. }
8134. }
8135. match(RPAREN);
8136. break;
8137. }
8138. case DOT:
8139. {
8140. match(DOT);
8141. id_expression();
8142. break;
8143. }
8144. case POINTERTO:
8145. {
8146. match(POINTERTO);
8147. id_expression();
8148. break;
8149. }
8150. case PLUSPLUS:
8151. {
8152. match(PLUSPLUS);
8153. break;
8154. }
8155. case MINUSMINUS:
8156. {
8157. match(MINUSMINUS);
8158. break;
8159. }
8160. default:
8161. {
8162. break _loop422;
8163. }
8164. }
8165. } while (true);
8166. }
8167. }
8168. else if ((_tokenSet_74.member(LA(1)))) {
8169. {
8170. switch ( LA(1)) {
8171. case LITERAL_dynamic_cast:
8172. {
8173. match(LITERAL_dynamic_cast);
8174. break;
8175. }
8176. case LITERAL_static_cast:
8177. {
8178. match(LITERAL_static_cast);
8179. break;
8180. }
8181. case LITERAL_reinterpret_cast:
8182. {
8183. match(LITERAL_reinterpret_cast);
8184. break;
8185. }
8186. case LITERAL_const_cast:
8187. {
8188. match(LITERAL_const_cast);
8189. break;
8190. }
8191. default:
8192. {
8193. throw new NoViableAltException(LT(1), getFilename());
8194. }
8195. }
8196. }
8197. match(LESSTHAN);
8198. type_specifier();
8199. {
8200. switch ( LA(1)) {
8201. case ID:
8202. case LITERAL__stdcall:
8203. case LITERAL___stdcall:
8204. case STAR:
8205. case AMPERSAND:
8206. case SCOPE:
8207. case LITERAL__cdecl:
8208. case LITERAL___cdecl:
8209. case LITERAL__near:
8210. case LITERAL___near:
8211. case LITERAL__far:
8212. case LITERAL___far:
8213. case LITERAL___interrupt:
8214. case LITERAL_pascal:
8215. case LITERAL__pascal:
8216. case LITERAL___pascal:
8217. {
8218. ptr_operator();
8219. break;
8220. }
8221. case GREATERTHAN:
8222. {
8223. break;
8224. }
8225. default:
8226. {
8227. throw new NoViableAltException(LT(1), getFilename());
8228. }
8229. }
8230. }
8231. match(GREATERTHAN);
8232. match(LPAREN);
8233. expression();
8234. match(RPAREN);
8235. }
8236. else {
8237. throw new NoViableAltException(LT(1), getFilename());
8238. }
8239. }
8240. }
8241. }
8242.
8243. public final void unary_operator() throws RecognitionException, TokenStreamException {
8244.
8245.
8246. switch ( LA(1)) {
8247. case AMPERSAND:
8248. {
8249. match(AMPERSAND);
8250. break;
8251. }
8252. case STAR:
8253. {
8254. match(STAR);
8255. break;
8256. }
8257. case PLUS:
8258. {
8259. match(PLUS);
8260. break;
8261. }
8262. case MINUS:
8263. {
8264. match(MINUS);
8265. break;
8266. }
8267. case TILDE:
8268. {
8269. match(TILDE);
8270. break;
8271. }
8272. case NOT:
8273. {
8274. match(NOT);
8275. break;
8276. }
8277. default:
8278. {
8279. throw new NoViableAltException(LT(1), getFilename());
8280. }
8281. }
8282. }
8283.
8284. public final void new_expression() throws RecognitionException, TokenStreamException {
8285.
8286.
8287. {
8288. match(LITERAL_new);
8289. {
8290. boolean synPredMatched434 = false;
8291. if (((LA(1)==LPAREN) && (_tokenSet_42.member(LA(2))))) {
8292. int _m434 = mark();
8293. synPredMatched434 = true;
8294. inputState.guessing++;
8295. try {
8296. {
8297. match(LPAREN);
8298. expression_list();
8299. match(RPAREN);
8300. }
8301. }
8302. catch (RecognitionException pe) {
8303. synPredMatched434 = false;
8304. }
8305. rewind(_m434);
8306. inputState.guessing--;
8307. }
8308. if ( synPredMatched434 ) {
8309. match(LPAREN);
8310. expression_list();
8311. match(RPAREN);
8312. }
8313. else if ((_tokenSet_75.member(LA(1))) && (_tokenSet_76.member(LA(2)))) {
8314. }
8315. else {
8316. throw new NoViableAltException(LT(1), getFilename());
8317. }
8318.
8319. }
8320. {
8321. switch ( LA(1)) {
8322. case LITERAL_typedef:
8323. case LITERAL_enum:
8324. case ID:
8325. case LITERAL_inline:
8326. case LITERAL_extern:
8327. case LITERAL__inline:
8328. case LITERAL___inline:
8329. case LITERAL_virtual:
8330. case LITERAL_explicit:
8331. case LITERAL_friend:
8332. case LITERAL__stdcall:
8333. case LITERAL___stdcall:
8334. case LITERAL__declspec:
8335. case LITERAL___declspec:
8336. case LITERAL_typename:
8337. case LITERAL_auto:
8338. case LITERAL_register:
8339. case LITERAL_static:
8340. case LITERAL_mutable:
8341. case LITERAL_const:
8342. case LITERAL_const_cast:
8343. case LITERAL_volatile:
8344. case LITERAL_char:
8345. case LITERAL_wchar_t:
8346. case LITERAL_bool:
8347. case LITERAL_short:
8348. case LITERAL_int:
8349. case 44:
8350. case 45:
8351. case 46:
8352. case LITERAL_long:
8353. case LITERAL_signed:
8354. case LITERAL_unsigned:
8355. case LITERAL_float:
8356. case LITERAL_double:
8357. case LITERAL_void:
8358. case LITERAL_class:
8359. case LITERAL_struct:
8360. case LITERAL_union:
8361. case SCOPE:
8362. {
8363. new_type_id();
8364. break;
8365. }
8366. case LPAREN:
8367. {
8368. match(LPAREN);
8369. type_name();
8370. match(RPAREN);
8371. break;
8372. }
8373. default:
8374. {
8375. throw new NoViableAltException(LT(1), getFilename());
8376. }
8377. }
8378. }
8379. {
8380. switch ( LA(1)) {
8381. case LPAREN:
8382. {
8383. new_initializer();
8384. break;
8385. }
8386. case LESSTHAN:
8387. case GREATERTHAN:
8388. case SEMICOLON:
8389. case RCURLY:
8390. case ASSIGNEQUAL:
8391. case COLON:
8392. case COMMA:
8393. case RPAREN:
8394. case STAR:
8395. case AMPERSAND:
8396. case RSQUARE:
8397. case ELLIPSIS:
8398. case TIMESEQUAL:
8399. case DIVIDEEQUAL:
8400. case MINUSEQUAL:
8401. case PLUSEQUAL:
8402. case MODEQUAL:
8403. case SHIFTLEFTEQUAL:
8404. case SHIFTRIGHTEQUAL:
8405. case BITWISEANDEQUAL:
8406. case BITWISEXOREQUAL:
8407. case BITWISEOREQUAL:
8408. case QUESTIONMARK:
8409. case OR:
8410. case AND:
8411. case BITWISEOR:
8412. case BITWISEXOR:
8413. case NOTEQUAL:
8414. case EQUAL:
8415. case LESSTHANOREQUALTO:
8416. case GREATERTHANOREQUALTO:
8417. case SHIFTLEFT:
8418. case SHIFTRIGHT:
8419. case PLUS:
8420. case MINUS:
8421. case DIVIDE:
8422. case MOD:
8423. case DOTMBR:
8424. case POINTERTOMBR:
8425. {
8426. break;
8427. }
8428. default:
8429. {
8430. throw new NoViableAltException(LT(1), getFilename());
8431. }
8432. }
8433. }
8434. }
8435. }
8436.
8437. public final void delete_expression() throws RecognitionException, TokenStreamException {
8438.
8439.
8440. match(LITERAL_delete);
8441. {
8442. switch ( LA(1)) {
8443. case LSQUARE:
8444. {
8445. match(LSQUARE);
8446. match(RSQUARE);
8447. break;
8448. }
8449. case ID:
8450. case StringLiteral:
8451. case LITERAL__declspec:
8452. case LITERAL___declspec:
8453. case LPAREN:
8454. case LITERAL_const_cast:
8455. case LITERAL_char:
8456. case LITERAL_wchar_t:
8457. case LITERAL_bool:
8458. case LITERAL_short:
8459. case LITERAL_int:
8460. case 44:
8461. case 45:
8462. case 46:
8463. case LITERAL_long:
8464. case LITERAL_signed:
8465. case LITERAL_unsigned:
8466. case LITERAL_float:
8467. case LITERAL_double:
8468. case LITERAL_void:
8469. case OPERATOR:
8470. case LITERAL_this:
8471. case LITERAL_true:
8472. case LITERAL_false:
8473. case OCTALINT:
8474. case STAR:
8475. case AMPERSAND:
8476. case TILDE:
8477. case PLUS:
8478. case MINUS:
8479. case PLUSPLUS:
8480. case MINUSMINUS:
8481. case LITERAL_sizeof:
8482. case SCOPE:
8483. case LITERAL_dynamic_cast:
8484. case LITERAL_static_cast:
8485. case LITERAL_reinterpret_cast:
8486. case NOT:
8487. case LITERAL_new:
8488. case LITERAL_delete:
8489. case DECIMALINT:
8490. case HEXADECIMALINT:
8491. case CharLiteral:
8492. case FLOATONE:
8493. case FLOATTWO:
8494. {
8495. break;
8496. }
8497. default:
8498. {
8499. throw new NoViableAltException(LT(1), getFilename());
8500. }
8501. }
8502. }
8503. cast_expression();
8504. }
8505.
8506. public final void primary_expression() throws RecognitionException, TokenStreamException {
8507.
8508.
8509. switch ( LA(1)) {
8510. case ID:
8511. case OPERATOR:
8512. case TILDE:
8513. case SCOPE:
8514. {
8515. id_expression();
8516. break;
8517. }
8518. case StringLiteral:
8519. case LITERAL_true:
8520. case LITERAL_false:
8521. case OCTALINT:
8522. case DECIMALINT:
8523. case HEXADECIMALINT:
8524. case CharLiteral:
8525. case FLOATONE:
8526. case FLOATTWO:
8527. {
8528. constant();
8529. break;
8530. }
8531. case LITERAL_this:
8532. {
8533. match(LITERAL_this);
8534. break;
8535. }
8536. case LPAREN:
8537. {
8538. match(LPAREN);
8539. expression();
8540. match(RPAREN);
8541. break;
8542. }
8543. default:
8544. {
8545. throw new NoViableAltException(LT(1), getFilename());
8546. }
8547. }
8548. }
8549.
8550. public final void id_expression() throws RecognitionException, TokenStreamException {
8551.
8552. String s="";
8553.
8554. s=scope_override();
8555. {
8556. switch ( LA(1)) {
8557. case ID:
8558. {
8559. match(ID);
8560. break;
8561. }
8562. case OPERATOR:
8563. {
8564. match(OPERATOR);
8565. optor();
8566. break;
8567. }
8568. case TILDE:
8569. {
8570. match(TILDE);
8571. {
8572. switch ( LA(1)) {
8573. case STAR:
8574. {
8575. match(STAR);
8576. break;
8577. }
8578. case ID:
8579. {
8580. break;
8581. }
8582. default:
8583. {
8584. throw new NoViableAltException(LT(1), getFilename());
8585. }
8586. }
8587. }
8588. match(ID);
8589. break;
8590. }
8591. default:
8592. {
8593. throw new NoViableAltException(LT(1), getFilename());
8594. }
8595. }
8596. }
8597. }
8598.
8599. public final void constant() throws RecognitionException, TokenStreamException {
8600.
8601.
8602. switch ( LA(1)) {
8603. case OCTALINT:
8604. {
8605. match(OCTALINT);
8606. break;
8607. }
8608. case DECIMALINT:
8609. {
8610. match(DECIMALINT);
8611. break;
8612. }
8613. case HEXADECIMALINT:
8614. {
8615. match(HEXADECIMALINT);
8616. break;
8617. }
8618. case CharLiteral:
8619. {
8620. match(CharLiteral);
8621. break;
8622. }
8623. case StringLiteral:
8624. {
8625. {
8626. int _cnt468=0;
8627. _loop468:
8628. do {
8629. if ((LA(1)==StringLiteral)) {
8630. match(StringLiteral);
8631. }
8632. else {
8633. if ( _cnt468>=1 ) { break _loop468; } else {throw new NoViableAltException(LT(1), getFilename()...8634. }
8635.
8636. _cnt468++;
8637. } while (true);
8638. }
8639. break;
8640. }
8641. case FLOATONE:
8642. {
8643. match(FLOATONE);
8644. break;
8645. }
8646. case FLOATTWO:
8647. {
8648. match(FLOATTWO);
8649. break;
8650. }
8651. case LITERAL_true:
8652. {
8653. match(LITERAL_true);
8654. break;
8655. }
8656. case LITERAL_false:
8657. {
8658. match(LITERAL_false);
8659. break;
8660. }
8661. default:
8662. {
8663. throw new NoViableAltException(LT(1), getFilename());
8664. }
8665. }
8666. }
8667.
8668. public final void new_type_id() throws RecognitionException, TokenStreamException {
8669.
8670.
8671. declaration_specifiers();
8672. {
8673. if ((_tokenSet_77.member(LA(1))) && (_tokenSet_78.member(LA(2)))) {
8674. new_declarator();
8675. }
8676. else if ((_tokenSet_79.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
8677. }
8678. else {
8679. throw new NoViableAltException(LT(1), getFilename());
8680. }
8681.
8682. }
8683. }
8684.
8685. public final void new_initializer() throws RecognitionException, TokenStreamException {
8686.
8687.
8688. match(LPAREN);
8689. {
8690. switch ( LA(1)) {
8691. case ID:
8692. case StringLiteral:
8693. case LITERAL__declspec:
8694. case LITERAL___declspec:
8695. case LPAREN:
8696. case LITERAL_const_cast:
8697. case LITERAL_char:
8698. case LITERAL_wchar_t:
8699. case LITERAL_bool:
8700. case LITERAL_short:
8701. case LITERAL_int:
8702. case 44:
8703. case 45:
8704. case 46:
8705. case LITERAL_long:
8706. case LITERAL_signed:
8707. case LITERAL_unsigned:
8708. case LITERAL_float:
8709. case LITERAL_double:
8710. case LITERAL_void:
8711. case OPERATOR:
8712. case LITERAL_this:
8713. case LITERAL_true:
8714. case LITERAL_false:
8715. case OCTALINT:
8716. case STAR:
8717. case AMPERSAND:
8718. case TILDE:
8719. case PLUS:
8720. case MINUS:
8721. case PLUSPLUS:
8722. case MINUSMINUS:
8723. case LITERAL_sizeof:
8724. case SCOPE:
8725. case LITERAL_dynamic_cast:
8726. case LITERAL_static_cast:
8727. case LITERAL_reinterpret_cast:
8728. case NOT:
8729. case LITERAL_new:
8730. case LITERAL_delete:
8731. case DECIMALINT:
8732. case HEXADECIMALINT:
8733. case CharLiteral:
8734. case FLOATONE:
8735. case FLOATTWO:
8736. {
8737. expression_list();
8738. break;
8739. }
8740. case RPAREN:
8741. {
8742. break;
8743. }
8744. default:
8745. {
8746. throw new NoViableAltException(LT(1), getFilename());
8747. }
8748. }
8749. }
8750. match(RPAREN);
8751. }
8752.
8753. public final void new_declarator() throws RecognitionException, TokenStreamException {
8754.
8755.
8756. switch ( LA(1)) {
8757. case ID:
8758. case LITERAL__stdcall:
8759. case LITERAL___stdcall:
8760. case STAR:
8761. case AMPERSAND:
8762. case SCOPE:
8763. case LITERAL__cdecl:
8764. case LITERAL___cdecl:
8765. case LITERAL__near:
8766. case LITERAL___near:
8767. case LITERAL__far:
8768. case LITERAL___far:
8769. case LITERAL___interrupt:
8770. case LITERAL_pascal:
8771. case LITERAL__pascal:
8772. case LITERAL___pascal:
8773. {
8774. ptr_operator();
8775. {
8776. if ((_tokenSet_77.member(LA(1))) && (_tokenSet_78.member(LA(2)))) {
8777. new_declarator();
8778. }
8779. else if ((_tokenSet_79.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
8780. }
8781. else {
8782. throw new NoViableAltException(LT(1), getFilename());
8783. }
8784.
8785. }
8786. break;
8787. }
8788. case LSQUARE:
8789. {
8790. direct_new_declarator();
8791. break;
8792. }
8793. default:
8794. {
8795. throw new NoViableAltException(LT(1), getFilename());
8796. }
8797. }
8798. }
8799.
8800. public final void direct_new_declarator() throws RecognitionException, TokenStreamException {
8801.
8802.
8803. {
8804. int _cnt460=0;
8805. _loop460:
8806. do {
8807. if ((LA(1)==LSQUARE)) {
8808. match(LSQUARE);
8809. expression();
8810. match(RSQUARE);
8811. }
8812. else {
8813. if ( _cnt460>=1 ) { break _loop460; } else {throw new NoViableAltException(LT(1), getFilename())...8814. }
8815.
8816. _cnt460++;
8817. } while (true);
8818. }
8819. }
8820.
8821. public final void ptr_to_member() throws RecognitionException, TokenStreamException {
8822.
8823. String s="";
8824.
8825. s=scope_override();
8826. match(STAR);
8827. if ( inputState.guessing==0 ) {
8828.
8829. if (s.length() != 0) m.ptrToMember(s, "*");
8830. else m.ptrOperator("*");
8831.
8832. }
8833. cv_qualifier_seq();
8834. }
8835.
8836. public final void optor_simple_tokclass() throws RecognitionException, TokenStreamException {
8837.
8838.
8839. {
8840. switch ( LA(1)) {
8841. case PLUS:
8842. {
8843. match(PLUS);
8844. break;
8845. }
8846. case MINUS:
8847. {
8848. match(MINUS);
8849. break;
8850. }
8851. case STAR:
8852. {
8853. match(STAR);
8854. break;
8855. }
8856. case DIVIDE:
8857. {
8858. match(DIVIDE);
8859. break;
8860. }
8861. case MOD:
8862. {
8863. match(MOD);
8864. break;
8865. }
8866. case BITWISEXOR:
8867. {
8868. match(BITWISEXOR);
8869. break;
8870. }
8871. case AMPERSAND:
8872. {
8873. match(AMPERSAND);
8874. break;
8875. }
8876. case BITWISEOR:
8877. {
8878. match(BITWISEOR);
8879. break;
8880. }
8881. case TILDE:
8882. {
8883. match(TILDE);
8884. break;
8885. }
8886. case NOT:
8887. {
8888. match(NOT);
8889. break;
8890. }
8891. case SHIFTLEFT:
8892. {
8893. match(SHIFTLEFT);
8894. break;
8895. }
8896. case SHIFTRIGHT:
8897. {
8898. match(SHIFTRIGHT);
8899. break;
8900. }
8901. case ASSIGNEQUAL:
8902. {
8903. match(ASSIGNEQUAL);
8904. break;
8905. }
8906. case TIMESEQUAL:
8907. {
8908. match(TIMESEQUAL);
8909. break;
8910. }
8911. case DIVIDEEQUAL:
8912. {
8913. match(DIVIDEEQUAL);
8914. break;
8915. }
8916. case MODEQUAL:
8917. {
8918. match(MODEQUAL);
8919. break;
8920. }
8921. case PLUSEQUAL:
8922. {
8923. match(PLUSEQUAL);
8924. break;
8925. }
8926. case MINUSEQUAL:
8927. {
8928. match(MINUSEQUAL);
8929. break;
8930. }
8931. case SHIFTLEFTEQUAL:
8932. {
8933. match(SHIFTLEFTEQUAL);
8934. break;
8935. }
8936. case SHIFTRIGHTEQUAL:
8937. {
8938. match(SHIFTRIGHTEQUAL);
8939. break;
8940. }
8941. case BITWISEANDEQUAL:
8942. {
8943. match(BITWISEANDEQUAL);
8944. break;
8945. }
8946. case BITWISEXOREQUAL:
8947. {
8948. match(BITWISEXOREQUAL);
8949. break;
8950. }
8951. case BITWISEOREQUAL:
8952. {
8953. match(BITWISEOREQUAL);
8954. break;
8955. }
8956. case EQUAL:
8957. {
8958. match(EQUAL);
8959. break;
8960. }
8961. case NOTEQUAL:
8962. {
8963. match(NOTEQUAL);
8964. break;
8965. }
8966. case LESSTHAN:
8967. {
8968. match(LESSTHAN);
8969. break;
8970. }
8971. case GREATERTHAN:
8972. {
8973. match(GREATERTHAN);
8974. break;
8975. }
8976. case LESSTHANOREQUALTO:
8977. {
8978. match(LESSTHANOREQUALTO);
8979. break;
8980. }
8981. case GREATERTHANOREQUALTO:
8982. {
8983. match(GREATERTHANOREQUALTO);
8984. break;
8985. }
8986. case OR:
8987. {
8988. match(OR);
8989. break;
8990. }
8991. case AND:
8992. {
8993. match(AND);
8994. break;
8995. }
8996. case PLUSPLUS:
8997. {
8998. match(PLUSPLUS);
8999. break;
9000. }
9001. case MINUSMINUS:
9002. {
9003. match(MINUSMINUS);
9004. break;
9005. }
9006. case COMMA:
9007. {
9008. match(COMMA);
9009. break;
9010. }
9011. case POINTERTO:
9012. {
9013. match(POINTERTO);
9014. break;
9015. }
9016. case POINTERTOMBR:
9017. {
9018. match(POINTERTOMBR);
9019. break;
9020. }
9021. default:
9022. {
9023. throw new NoViableAltException(LT(1), getFilename());
9024. }
9025. }
9026. }
9027. }
9028.
9029.
9030. public static final String[] _tokenNames = {
9031. "<0>",
9032. "EOF",
9033. "<2>",
9034. "NULL_TREE_LOOKAHEAD",
9035. "\"template\"",
9036. "LESSTHAN",
9037. "GREATERTHAN",
9038. "\"typedef\"",
9039. "\"enum\"",
9040. "ID",
9041. "LCURLY",
9042. "SEMICOLON",
9043. "\"inline\"",
9044. "\"namespace\"",
9045. "RCURLY",
9046. "ASSIGNEQUAL",
9047. "COLON",
9048. "\"extern\"",
9049. "StringLiteral",
9050. "COMMA",
9051. "\"_inline\"",
9052. "\"__inline\"",
9053. "\"virtual\"",
9054. "\"explicit\"",
9055. "\"friend\"",
9056. "\"_stdcall\"",
9057. "\"__stdcall\"",
9058. "\"_declspec\"",
9059. "\"__declspec\"",
9060. "LPAREN",
9061. "RPAREN",
9062. "\"typename\"",
9063. "\"auto\"",
9064. "\"register\"",
9065. "\"static\"",
9066. "\"mutable\"",
9067. "\"const\"",
9068. "\"const_cast\"",
9069. "\"volatile\"",
9070. "\"char\"",
9071. "\"wchar_t\"",
9072. "\"bool\"",
9073. "\"short\"",
9074. "\"int\"",
9075. "\"_int64\"",
9076. "\"__int64\"",
9077. "\"__w64\"",
9078. "\"long\"",
9079. "\"signed\"",
9080. "\"unsigned\"",
9081. "\"float\"",
9082. "\"double\"",
9083. "\"void\"",
9084. "\"class\"",
9085. "\"struct\"",
9086. "\"union\"",
9087. "\"operator\"",
9088. "\"this\"",
9089. "\"true\"",
9090. "\"false\"",
9091. "\"public\"",
9092. "\"protected\"",
9093. "\"private\"",
9094. "OCTALINT",
9095. "STAR",
9096. "AMPERSAND",
9097. "LSQUARE",
9098. "RSQUARE",
9099. "TILDE",
9100. "ELLIPSIS",
9101. "\"throw\"",
9102. "\"case\"",
9103. "\"default\"",
9104. "\"if\"",
9105. "\"else\"",
9106. "\"switch\"",
9107. "\"while\"",
9108. "\"do\"",
9109. "\"for\"",
9110. "\"goto\"",
9111. "\"continue\"",
9112. "\"break\"",
9113. "\"return\"",
9114. "\"try\"",
9115. "\"catch\"",
9116. "\"using\"",
9117. "\"_asm\"",
9118. "\"__asm\"",
9119. "TIMESEQUAL",
9120. "DIVIDEEQUAL",
9121. "MINUSEQUAL",
9122. "PLUSEQUAL",
9123. "MODEQUAL",
9124. "SHIFTLEFTEQUAL",
9125. "SHIFTRIGHTEQUAL",
9126. "BITWISEANDEQUAL",
9127. "BITWISEXOREQUAL",
9128. "BITWISEOREQUAL",
9129. "QUESTIONMARK",
9130. "OR",
9131. "AND",
9132. "BITWISEOR",
9133. "BITWISEXOR",
9134. "NOTEQUAL",
9135. "EQUAL",
9136. "LESSTHANOREQUALTO",
9137. "GREATERTHANOREQUALTO",
9138. "SHIFTLEFT",
9139. "SHIFTRIGHT",
9140. "PLUS",
9141. "MINUS",
9142. "DIVIDE",
9143. "MOD",
9144. "DOTMBR",
9145. "POINTERTOMBR",
9146. "PLUSPLUS",
9147. "MINUSMINUS",
9148. "\"sizeof\"",
9149. "SCOPE",
9150. "DOT",
9151. "POINTERTO",
9152. "\"dynamic_cast\"",
9153. "\"static_cast\"",
9154. "\"reinterpret_cast\"",
9155. "NOT",
9156. "\"new\"",
9157. "\"_cdecl\"",
9158. "\"__cdecl\"",
9159. "\"_near\"",
9160. "\"__near\"",
9161. "\"_far\"",
9162. "\"__far\"",
9163. "\"__interrupt\"",
9164. "\"pascal\"",
9165. "\"_pascal\"",
9166. "\"__pascal\"",
9167. "\"delete\"",
9168. "DECIMALINT",
9169. "HEXADECIMALINT",
9170. "CharLiteral",
9171. "FLOATONE",
9172. "FLOATTWO",
9173. "Whitespace",
9174. "Comment",
9175. "CPPComment",
9176. "DIRECTIVE",
9177. "LineDirective",
9178. "EndOfLine",
9179. "Escape",
9180. "Digit",
9181. "Decimal",
9182. "LongSuffix",
9183. "UnsignedSuffix",
9184. "FloatSuffix",
9185. "Exponent",
9186. "Vocabulary",
9187. "Number"
9188. };
9189.
9190. private static final long[] mk_tokenSet_0() {
9191. long[] data = { 1152921503532202896L, -4593671619915808749L, 255L, 0L, 0L, 0L};
9192. return data;
9193. }
9194. public static final BitSet _tokenSet_0 = new BitSet(mk_tokenSet_0());
9195. private static final long[] mk_tokenSet_1() {
9196. long[] data = { 72057592426402688L, 18014398511579136L, 0L, 0L};
9197. return data;
9198. }
9199. public static final BitSet _tokenSet_1 = new BitSet(mk_tokenSet_1());
9200. private static final long[] mk_tokenSet_2() {
9201. long[] data = { 1152921501385506720L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9202. return data;
9203. }
9204. public static final BitSet _tokenSet_2 = new BitSet(mk_tokenSet_2());
9205. private static final long[] mk_tokenSet_3() {
9206. long[] data = { 7344656L, 18014398509482000L, 0L, 0L};
9207. return data;
9208. }
9209. public static final BitSet _tokenSet_3 = new BitSet(mk_tokenSet_3());
9210. private static final long[] mk_tokenSet_4() {
9211. long[] data = { 7344672L, 18014398509482000L, 0L, 0L};
9212. return data;
9213. }
9214. public static final BitSet _tokenSet_4 = new BitSet(mk_tokenSet_4());
9215. private static final long[] mk_tokenSet_5() {
9216. long[] data = { 11538944L, 18014398509481984L, 0L, 0L};
9217. return data;
9218. }
9219. public static final BitSet _tokenSet_5 = new BitSet(mk_tokenSet_5());
9220. private static final long[] mk_tokenSet_6() {
9221. long[] data = { 548409888L, 18014398509481984L, 0L, 0L};
9222. return data;
9223. }
9224. public static final BitSet _tokenSet_6 = new BitSet(mk_tokenSet_6());
9225. private static final long[] mk_tokenSet_7() {
9226. long[] data = { 72057594037932544L, 18014398509481984L, 0L, 0L};
9227. return data;
9228. }
9229. public static final BitSet _tokenSet_7 = new BitSet(mk_tokenSet_7());
9230. private static final long[] mk_tokenSet_8() {
9231. long[] data = { 144115186464330656L, 18014398509481984L, 0L, 0L};
9232. return data;
9233. }
9234. public static final BitSet _tokenSet_8 = new BitSet(mk_tokenSet_8());
9235. private static final long[] mk_tokenSet_9() {
9236. long[] data = { 1152921503532192640L, -4593671619917905917L, 255L, 0L, 0L, 0L};
9237. return data;
9238. }
9239. public static final BitSet _tokenSet_9 = new BitSet(mk_tokenSet_9());
9240. private static final long[] mk_tokenSet_10() {
9241. long[] data = { 1152921501385267168L, -1054405279954763753L, 511L, 0L, 0L, 0L};
9242. return data;
9243. }
9244. public static final BitSet _tokenSet_10 = new BitSet(mk_tokenSet_10());
9245. private static final long[] mk_tokenSet_11() {
9246. long[] data = { 72057592426402688L, 18014398509481984L, 0L, 0L};
9247. return data;
9248. }
9249. public static final BitSet _tokenSet_11 = new BitSet(mk_tokenSet_11());
9250. private static final long[] mk_tokenSet_12() {
9251. long[] data = { 1152921501385236384L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9252. return data;
9253. }
9254. public static final BitSet _tokenSet_12 = new BitSet(mk_tokenSet_12());
9255. private static final long[] mk_tokenSet_13() {
9256. long[] data = { 100663808L, -4593671619917905917L, 255L, 0L, 0L, 0L};
9257. return data;
9258. }
9259. public static final BitSet _tokenSet_13 = new BitSet(mk_tokenSet_13());
9260. private static final long[] mk_tokenSet_14() {
9261. long[] data = { 1080864392242790944L, -4593671619917905917L, 255L, 0L, 0L, 0L};
9262. return data;
9263. }
9264. public static final BitSet _tokenSet_14 = new BitSet(mk_tokenSet_14());
9265. private static final long[] mk_tokenSet_15() {
9266. long[] data = { 1080863911105790464L, 18014398509481984L, 0L, 0L};
9267. return data;
9268. }
9269. public static final BitSet _tokenSet_15 = new BitSet(mk_tokenSet_15());
9270. private static final long[] mk_tokenSet_16() {
9271. long[] data = { 1080863911106347616L, 3557280738472624151L, 256L, 0L, 0L, 0L};
9272. return data;
9273. }
9274. public static final BitSet _tokenSet_16 = new BitSet(mk_tokenSet_16());
9275. private static final long[] mk_tokenSet_17() {
9276. long[] data = { 1152921501384710048L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9277. return data;
9278. }
9279. public static final BitSet _tokenSet_17 = new BitSet(mk_tokenSet_17());
9280. private static final long[] mk_tokenSet_18() {
9281. long[] data = { 72057592426403712L, 18014398511579136L, 0L, 0L};
9282. return data;
9283. }
9284. public static final BitSet _tokenSet_18 = new BitSet(mk_tokenSet_18());
9285. private static final long[] mk_tokenSet_19() {
9286. long[] data = { -8070450533321769056L, -110232637738583085L, 16383L, 0L, 0L, 0L};
9287. return data;
9288. }
9289. public static final BitSet _tokenSet_19 = new BitSet(mk_tokenSet_19());
9290. private static final long[] mk_tokenSet_20() {
9291. long[] data = { -8070450533322301568L, 4501453380688804819L, 16128L, 0L, 0L, 0L};
9292. return data;
9293. }
9294. public static final BitSet _tokenSet_20 = new BitSet(mk_tokenSet_20());
9295. private static final long[] mk_tokenSet_21() {
9296. long[] data = { 1080863911206453760L, -4593671619917905917L, 255L, 0L, 0L, 0L};
9297. return data;
9298. }
9299. public static final BitSet _tokenSet_21 = new BitSet(mk_tokenSet_21());
9300. private static final long[] mk_tokenSet_22() {
9301. long[] data = { 1080864392243348064L, -1054405279954763753L, 511L, 0L, 0L, 0L};
9302. return data;
9303. }
9304. public static final BitSet _tokenSet_22 = new BitSet(mk_tokenSet_22());
9305. private static final long[] mk_tokenSet_23() {
9306. long[] data = { 1152921503532220304L, -4593671619915808749L, 255L, 0L, 0L, 0L};
9307. return data;
9308. }
9309. public static final BitSet _tokenSet_23 = new BitSet(mk_tokenSet_23());
9310. private static final long[] mk_tokenSet_24() {
9311. long[] data = { -8070450533322321024L, 4501453380673077267L, 16128L, 0L, 0L, 0L};
9312. return data;
9313. }
9314. public static final BitSet _tokenSet_24 = new BitSet(mk_tokenSet_24());
9315. private static final long[] mk_tokenSet_25() {
9316. long[] data = { 1080863912280837728L, -4591419820120997825L, 255L, 0L, 0L, 0L};
9317. return data;
9318. }
9319. public static final BitSet _tokenSet_25 = new BitSet(mk_tokenSet_25());
9320. private static final long[] mk_tokenSet_26() {
9321. long[] data = { -14L, -1048577L, 16383L, 0L, 0L, 0L};
9322. return data;
9323. }
9324. public static final BitSet _tokenSet_26 = new BitSet(mk_tokenSet_26());
9325. private static final long[] mk_tokenSet_27() {
9326. long[] data = { 7344640L, 18014398509482000L, 0L, 0L};
9327. return data;
9328. }
9329. public static final BitSet _tokenSet_27 = new BitSet(mk_tokenSet_27());
9330. private static final long[] mk_tokenSet_28() {
9331. long[] data = { 144115186464330624L, 18014398509481984L, 0L, 0L};
9332. return data;
9333. }
9334. public static final BitSet _tokenSet_28 = new BitSet(mk_tokenSet_28());
9335. private static final long[] mk_tokenSet_29() {
9336. long[] data = { 1080863910568919552L, 18014398509481984L, 0L, 0L};
9337. return data;
9338. }
9339. public static final BitSet _tokenSet_29 = new BitSet(mk_tokenSet_29());
9340. private static final long[] mk_tokenSet_30() {
9341. long[] data = { 1080863911106349664L, 3557280738472624151L, 256L, 0L, 0L, 0L};
9342. return data;
9343. }
9344. public static final BitSet _tokenSet_30 = new BitSet(mk_tokenSet_30());
9345. private static final long[] mk_tokenSet_31() {
9346. long[] data = { 1152921501384777632L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9347. return data;
9348. }
9349. public static final BitSet _tokenSet_31 = new BitSet(mk_tokenSet_31());
9350. private static final long[] mk_tokenSet_32() {
9351. long[] data = { -8133501338408189440L, 4501453380673077275L, 16128L, 0L, 0L, 0L};
9352. return data;
9353. }
9354. public static final BitSet _tokenSet_32 = new BitSet(mk_tokenSet_32());
9355. private static final long[] mk_tokenSet_33() {
9356. long[] data = { 1080863912280836704L, -1053842312821473217L, 511L, 0L, 0L, 0L};
9357. return data;
9358. }
9359. public static final BitSet _tokenSet_33 = new BitSet(mk_tokenSet_33());
9360. private static final long[] mk_tokenSet_34() {
9361. long[] data = { 9006649901580288L, 0L, 0L};
9362. return data;
9363. }
9364. public static final BitSet _tokenSet_34 = new BitSet(mk_tokenSet_34());
9365. private static final long[] mk_tokenSet_35() {
9366. long[] data = { 9223372035780139920L, -4593671619915808749L, 255L, 0L, 0L, 0L};
9367. return data;
9368. }
9369. public static final BitSet _tokenSet_35 = new BitSet(mk_tokenSet_35());
9370. private static final long[] mk_tokenSet_36() {
9371. long[] data = { 9223372035780123536L, -4593671619915808749L, 255L, 0L, 0L, 0L};
9372. return data;
9373. }
9374. public static final BitSet _tokenSet_36 = new BitSet(mk_tokenSet_36());
9375. private static final long[] mk_tokenSet_37() {
9376. long[] data = { 1080863912280836704L, -4591419820120997825L, 255L, 0L, 0L, 0L};
9377. return data;
9378. }
9379. public static final BitSet _tokenSet_37 = new BitSet(mk_tokenSet_37());
9380. private static final long[] mk_tokenSet_38() {
9381. long[] data = { 1080863912280837728L, -4476578029623050177L, 255L, 0L, 0L, 0L};
9382. return data;
9383. }
9384. public static final BitSet _tokenSet_38 = new BitSet(mk_tokenSet_38());
9385. private static final long[] mk_tokenSet_39() {
9386. long[] data = { 1080864392242790944L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9387. return data;
9388. }
9389. public static final BitSet _tokenSet_39 = new BitSet(mk_tokenSet_39());
9390. private static final long[] mk_tokenSet_40() {
9391. long[] data = { 1080863911105790464L, 18014398509482000L, 0L, 0L};
9392. return data;
9393. }
9394. public static final BitSet _tokenSet_40 = new BitSet(mk_tokenSet_40());
9395. private static final long[] mk_tokenSet_41() {
9396. long[] data = { 1080863912280754784L, -1054405279954763721L, 511L, 0L, 0L, 0L};
9397. return data;
9398. }
9399. public static final BitSet _tokenSet_41 = new BitSet(mk_tokenSet_41());
9400. private static final long[] mk_tokenSet_42() {
9401. long[] data = { -8133501338408189440L, 4501453380673077267L, 16128L, 0L, 0L, 0L};
9402. return data;
9403. }
9404. public static final BitSet _tokenSet_42 = new BitSet(mk_tokenSet_42());
9405. private static final long[] mk_tokenSet_43() {
9406. long[] data = { -8070450532247938080L, 4611686018410610751L, 16128L, 0L, 0L, 0L};
9407. return data;
9408. }
9409. public static final BitSet _tokenSet_43 = new BitSet(mk_tokenSet_43());
9410. private static final long[] mk_tokenSet_44() {
9411. long[] data = { -8133501338408123904L, 4501453380673077267L, 16128L, 0L, 0L, 0L};
9412. return data;
9413. }
9414. public static final BitSet _tokenSet_44 = new BitSet(mk_tokenSet_44());
9415. private static final long[] mk_tokenSet_45() {
9416. long[] data = { 1080863911206453760L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9417. return data;
9418. }
9419. public static final BitSet _tokenSet_45 = new BitSet(mk_tokenSet_45());
9420. private static final long[] mk_tokenSet_46() {
9421. long[] data = { 1080864392243350112L, -1054405279954763753L, 511L, 0L, 0L, 0L};
9422. return data;
9423. }
9424. public static final BitSet _tokenSet_46 = new BitSet(mk_tokenSet_46());
9425. private static final long[] mk_tokenSet_47() {
9426. long[] data = { 72057592426438528L, 18014398511579200L, 0L, 0L};
9427. return data;
9428. }
9429. public static final BitSet _tokenSet_47 = new BitSet(mk_tokenSet_47());
9430. private static final long[] mk_tokenSet_48() {
9431. long[] data = { 1152921502459008992L, -4593671619917905865L, 255L, 0L, 0L, 0L};
9432. return data;
9433. }
9434. public static final BitSet _tokenSet_48 = new BitSet(mk_tokenSet_48());
9435. private static final long[] mk_tokenSet_49() {
9436. long[] data = { 1080864393317089888L, -1054405279954763721L, 511L, 0L, 0L, 0L};
9437. return data;
9438. }
9439. public static final BitSet _tokenSet_49 = new BitSet(mk_tokenSet_49());
9440. private static final long[] mk_tokenSet_50() {
9441. long[] data = { 1711833664L, -4593671619917905881L, 255L, 0L, 0L, 0L};
9442. return data;
9443. }
9444. public static final BitSet _tokenSet_50 = new BitSet(mk_tokenSet_50());
9445. private static final long[] mk_tokenSet_51() {
9446. long[] data = { -8070450532247937056L, -108086391071571841L, 16383L, 0L, 0L, 0L};
9447. return data;
9448. }
9449. public static final BitSet _tokenSet_51 = new BitSet(mk_tokenSet_51());
9450. private static final long[] mk_tokenSet_52() {
9451. long[] data = { 524864L, 0L, 0L};
9452. return data;
9453. }
9454. public static final BitSet _tokenSet_52 = new BitSet(mk_tokenSet_52());
9455. private static final long[] mk_tokenSet_53() {
9456. long[] data = { 1152921503532192640L, -4593671619917905869L, 255L, 0L, 0L, 0L};
9457. return data;
9458. }
9459. public static final BitSet _tokenSet_53 = new BitSet(mk_tokenSet_53());
9460. private static final long[] mk_tokenSet_54() {
9461. long[] data = { 638059104L, -4593671619917905913L, 255L, 0L, 0L, 0L};
9462. return data;
9463. }
9464. public static final BitSet _tokenSet_54 = new BitSet(mk_tokenSet_54());
9465. private static final long[] mk_tokenSet_55() {
9466. long[] data = { 9006649901580800L, 18014398509481984L, 0L, 0L};
9467. return data;
9468. }
9469. public static final BitSet _tokenSet_55 = new BitSet(mk_tokenSet_55());
9470. private static final long[] mk_tokenSet_56() {
9471. long[] data = { 9006650539639392L, -4593671619917905913L, 255L, 0L, 0L, 0L};
9472. return data;
9473. }
9474. public static final BitSet _tokenSet_56 = new BitSet(mk_tokenSet_56());
9475. private static final long[] mk_tokenSet_57() {
9476. long[] data = { 1152921501385234400L, -4593671619917905897L, 255L, 0L, 0L, 0L};
9477. return data;
9478. }
9479. public static final BitSet _tokenSet_57 = new BitSet(mk_tokenSet_57());
9480. private static final long[] mk_tokenSet_58() {
9481. long[] data = { -8070450533321763872L, 4611686001230741527L, 16128L, 0L, 0L, 0L};
9482. return data;
9483. }
9484. public static final BitSet _tokenSet_58 = new BitSet(mk_tokenSet_58());
9485. private static final long[] mk_tokenSet_59() {
9486. long[] data = { -8070450533322317952L, 4501453380688804819L, 16128L, 0L, 0L, 0L};
9487. return data;
9488. }
9489. public static final BitSet _tokenSet_59 = new BitSet(mk_tokenSet_59());
9490. private static final long[] mk_tokenSet_60() {
9491. long[] data = { -8070450533321761824L, 4611686018410610711L, 16128L, 0L, 0L, 0L};
9492. return data;
9493. }
9494. public static final BitSet _tokenSet_60 = new BitSet(mk_tokenSet_60());
9495. private static final long[] mk_tokenSet_61() {
9496. long[] data = { -8070450533322301568L, 4501453380688805843L, 16128L, 0L, 0L, 0L};
9497. return data;
9498. }
9499. public static final BitSet _tokenSet_61 = new BitSet(mk_tokenSet_61());
9500. private static final long[] mk_tokenSet_62() {
9501. long[] data = { -1073741838L, -41L, 16383L, 0L, 0L, 0L};
9502. return data;
9503. }
9504. public static final BitSet _tokenSet_62 = new BitSet(mk_tokenSet_62());
9505. private static final long[] mk_tokenSet_63() {
9506. long[] data = { -16400L, -1L, 536870911L, 0L, 0L, 0L};
9507. return data;
9508. }
9509. public static final BitSet _tokenSet_63 = new BitSet(mk_tokenSet_63());
9510. private static final long[] mk_tokenSet_64() {
9511. long[] data = { 96L, 6597069766656L, 0L, 0L};
9512. return data;
9513. }
9514. public static final BitSet _tokenSet_64 = new BitSet(mk_tokenSet_64());
9515. private static final long[] mk_tokenSet_65() {
9516. long[] data = { 0L, 422212465065985L, 0L, 0L};
9517. return data;
9518. }
9519. public static final BitSet _tokenSet_65 = new BitSet(mk_tokenSet_65());
9520. private static final long[] mk_tokenSet_66() {
9521. long[] data = { 9007130937917952L, 18014398509481984L, 0L, 0L};
9522. return data;
9523. }
9524. public static final BitSet _tokenSet_66 = new BitSet(mk_tokenSet_66());
9525. private static final long[] mk_tokenSet_67() {
9526. long[] data = { -8133501338408189440L, 1026820715040473104L, 15872L, 0L, 0L, 0L};
9527. return data;
9528. }
9529. public static final BitSet _tokenSet_67 = new BitSet(mk_tokenSet_67());
9530. private static final long[] mk_tokenSet_68() {
9531. long[] data = { -8133501337333806496L, 4611686018410610751L, 16128L, 0L, 0L, 0L};
9532. return data;
9533. }
9534. public static final BitSet _tokenSet_68 = new BitSet(mk_tokenSet_68());
9535. private static final long[] mk_tokenSet_69() {
9536. long[] data = { 0L, 1153027057723113491L, 0L, 0L};
9537. return data;
9538. }
9539. public static final BitSet _tokenSet_69 = new BitSet(mk_tokenSet_69());
9540. private static final long[] mk_tokenSet_70() {
9541. long[] data = { 0L, 2323857407723175936L, 256L, 0L, 0L, 0L};
9542. return data;
9543. }
9544. public static final BitSet _tokenSet_70 = new BitSet(mk_tokenSet_70());
9545. private static final long[] mk_tokenSet_71() {
9546. long[] data = { -8070450533322321024L, 4501453380673077271L, 16128L, 0L, 0L, 0L};
9547. return data;
9548. }
9549. public static final BitSet _tokenSet_71 = new BitSet(mk_tokenSet_71());
9550. private static final long[] mk_tokenSet_72() {
9551. long[] data = { 9006650438451744L, 18014398509481984L, 0L, 0L};
9552. return data;
9553. }
9554. public static final BitSet _tokenSet_72 = new BitSet(mk_tokenSet_72());
9555. private static final long[] mk_tokenSet_73() {
9556. long[] data = { -8142508125748723200L, 18014398509482000L, 15872L, 0L, 0L, 0L};
9557. return data;
9558. }
9559. public static final BitSet _tokenSet_73 = new BitSet(mk_tokenSet_73());
9560. private static final long[] mk_tokenSet_74() {
9561. long[] data = { 137438953472L, 1008806316530991104L, 0L, 0L};
9562. return data;
9563. }
9564. public static final BitSet _tokenSet_74 = new BitSet(mk_tokenSet_74());
9565. private static final long[] mk_tokenSet_75() {
9566. long[] data = { 72057592963273600L, 18014398509481984L, 0L, 0L};
9567. return data;
9568. }
9569. public static final BitSet _tokenSet_75 = new BitSet(mk_tokenSet_75());
9570. private static final long[] mk_tokenSet_76() {
9571. long[] data = { 1152921504606576608L, -4591419820120997825L, 255L, 0L, 0L, 0L};
9572. return data;
9573. }
9574. public static final BitSet _tokenSet_76 = new BitSet(mk_tokenSet_76());
9575. private static final long[] mk_tokenSet_77() {
9576. long[] data = { 100663808L, -4593671619917905913L, 255L, 0L, 0L, 0L};
9577. return data;
9578. }
9579. public static final BitSet _tokenSet_77 = new BitSet(mk_tokenSet_77());
9580. private static final long[] mk_tokenSet_78() {
9581. long[] data = { -8133500993635759520L, -108086391073669057L, 16383L, 0L, 0L, 0L};
9582. return data;
9583. }
9584. public static final BitSet _tokenSet_78 = new BitSet(mk_tokenSet_78());
9585. private static final long[] mk_tokenSet_79() {
9586. long[] data = { 1611253856L, 2251799796908075L, 0L, 0L};
9587. return data;
9588. }
9589. public static final BitSet _tokenSet_79 = new BitSet(mk_tokenSet_79());
9590.
9591. }
| 1. // $ANTLR 2.7.7 (20060930): "CppParser4Java.g" -> "CPPParser.java"$
2.
3. /*REMOVE_BEGIN*/
4. package org.argouml.language.cpp.reveng;
5. /*REMOVE_END*/
6.
7. import java.util.Hashtable;
8. import java.util.List;
9. import java.util.ArrayList;
10.
11. import antlr.TokenBuffer;
12. import antlr.TokenStreamException;
13. import antlr.TokenStreamIOException;
14. import antlr.ANTLRException;
15. import antlr.LLkParser;
16. import antlr.Token;
17. import antlr.TokenStream;
18. import antlr.RecognitionException;
19. import antlr.NoViableAltException;
20. import antlr.MismatchedTokenException;
21. import antlr.SemanticException;
22. import antlr.ParserSharedInputState;
23. import antlr.collections.impl.BitSet;
24.
25. public class CPPParser extends antlr.LLkParser implements STDCTokenTypes
26. {
27.
28.
29. private Modeler m;
30.
31. String enclosingClass="";//name of current class
32. boolean _td=false; // is type declaration?
33. Hashtable symbols=new Hashtable();
34.
35.
36. public boolean qualifiedItemIsOneOf(java.util.BitSet qiFlags, int lookahead_offset) throws TokenSt... 37. {
38. java.util.BitSet qi = qualifiedItemIs(lookahead_offset);
39. java.util.BitSet aux=(java.util.BitSet) qi.clone();
40. aux.and(qiFlags);
41. return (!aux.isEmpty());
42. }
43.
44.
45. // This is an important function, but will be replaced with
46. // an enhanced predicate in the future, once predicates
47. // and/or predicate guards can contain loops.
48. //
49. // Scan past the ::T::B:: to see what lies beyond.
50. // Return QI_TYPE if the qualified item can pose as type name.
51. // Note that T::T is NOT a type; it is a constructor. Also,
52. // class T { ... T...} yields the enclosed T as a ctor. This
53. // is probably a type as I separate out the constructor defs/decls,
54. // I want it consistent with T::T.
55. //
56. // In the below examples, I use A,B,T and example types, and
57. // a,b as example ids.
58. // In the below examples, any A or B may be a
59. // qualified template, i.e., A<...>
60. //
61. // T::T outside of class T yields QI_CTOR.
62. // T<...>::T outside of class T yields QI_CTOR.
63. // T inside of class T {...} yields QI_CTOR.
64. // T, ::T, A::T outside of class T yields QI_TYPE.
65. // a, ::a, A::B::a yields qiId
66. // a::b yields QI_INVALID
67. // ::operator, operator, A::B::operator yield qiOPerator
68. // A::*, A::B::* yield QI_PTR_MEMBER
69. // ::*, * yields QI_INVALID
70. // ::~T, ~T, A::~T yield QI_DTOR
71. // ~a, ~A::a, A::~T::, ~T:: yield QI_INVALID
72. public java.util.BitSet qualifiedItemIs(int lookahead_offset) throws TokenStreamException
73. {
74. int value;
75. int k = lookahead_offset + 1;
76. int final_type_idx = 0;
77. boolean scope_found = false;
78. // Skip leading "::"
79. if (LT(k).getType() == SCOPE)
80. {
81. k++;
82. scope_found = true;
83. }
84. // Skip sequences of T:: or T<...>::
85. //printf("support.cpp qualifiedItemIs while reached k %d type %d isType %d, isClass %d, guessing %... 86. // k,LT(k)->getType(),isTypeName((LT(k)->getText()).data()),isClassName((LT(k)->getText()).data())... 87. while ((LT(k).getType() == ID) && (isTypeName(LT(k).getText())))
88. {// If this type is the same as the last type, then ctor
89. if ((final_type_idx != 0) && (LT(final_type_idx).getText().equals(LT(k).getText())))
90. {// Like T::T
91. // As an extra check, do not allow T::T::
92. if (LT(k+1).getType() == SCOPE)
93. { //printf("support.cpp qualifiedItemIs QI_INVALID returned\n");
94. return CPPvariables.QI_INVALID;
95. }
96. else
97. {//printf("support.cpp qualifiedItemIs QI_CTOR returned\n");
98. return CPPvariables.QI_CTOR;
99. }
100. }
101.
102. // Record this as the most recent type seen in the series
103. final_type_idx = k;
104.
105. //printf("support.cpp qualifiedItemIs if step reached final_type_idx %d\n",final_type_idx);
106.
107. // Skip this token
108. k++;
109.
110. // Skip over any template qualifiers <...>
111. // I believe that "T<..." cannot be anything valid but a template
112. if (LT(k).getType() == LESSTHAN)
113. {
114. value=skipTemplateQualifiers(k);
115. if (value==k)
116. {//printf("support.cpp qualifiedItemIs QI_INVALID(2) returned\n");
117. return CPPvariables.QI_INVALID;
118. }
119. else
120. k=value;
121. //printf("support.cpp qualifiedItemIs template skipped, k %d\n",k);
122. // k has been updated to token following <...>
123. }
124. if (LT(k).getType() == SCOPE)
125. // Skip the "::" and keep going
126. {
127. k++;
128. scope_found = true;
129. }
130. else
131. {// Series terminated -- last ID in the sequence was a type
132. // Return ctor if last type is in containing class
133. // We already checked for T::T inside loop
134. if ( enclosingClass.equals(LT(final_type_idx).getText()))
135. { // Like class T T()
136. //printf("support.cpp qualifiedItemIs QI_CTOR(2) returned\n");
137. return CPPvariables.QI_CTOR;
138. }
139. else
140. {//printf("support.cpp qualifiedItemIs QI_TYPE returned\n");
141. return CPPvariables.QI_TYPE;
142. }
143. }
144. }
145. // LT(k) is not an ID, or it is an ID but not a typename.
146. //printf("support.cpp qualifiedItemIs second switch reached\n");
147. switch (LT(k).getType())
148. {
149. case ID:
150. // ID but not a typename
151. // Do not allow id::
152. if (LT(k+1).getType() == SCOPE)
153. {
154. //printf("support.cpp qualifiedItemIs QI_INVALID(3) returned\n");
155. return CPPvariables.QI_INVALID;
156. }
157. if (enclosingClass.equals(LT(k).getText()))
158. { // Like class T T()
159. //printf("support.cpp qualifiedItemIs QI_CTOR(3) returned\n");
160. return CPPvariables.QI_CTOR;
161. }
162. else
163. {
164. if (scope_found)
165. // DW 25/10/03 Assume type if at least one SCOPE present (test12.i)
166. return CPPvariables.QI_TYPE;
167. else
168. //printf("support.cpp qualifiedItemIs QI_VAR returned\n");
169. return CPPvariables.QI_VAR; // DW 19/03/04 was QI_ID Could be function?
170. }
171. case TILDE:
172. // check for dtor
173. if ((LT(k+1).getType() == ID) && (isTypeName(LT(k+1).getText())) &&(LT(k+2).getType() != SCOPE))... 174. { // Like ~B or A::B::~B
175. // Also (incorrectly?) matches ::~A.
176. //printf("support.cpp qualifiedItemIs QI_DTOR returned\n");
177. return CPPvariables.QI_DTOR;
178. }
179. else
180. { // ~a or ~A::a is QI_INVALID
181. //printf("support.cpp qualifiedItemIs QI_INVALID(4) returned\n");
182. return CPPvariables.QI_INVALID;
183. }
184. case STAR:
185. // Like A::*
186. // Do not allow * or ::*
187. if (final_type_idx == 0)
188. { // Haven't seen a type yet
189. //printf("support.cpp qualifiedItemIs QI_INVALID(5) returned\n");
190. return CPPvariables.QI_INVALID;
191. }
192. else
193. { //printf("support.cpp qualifiedItemIs QI_PTR_MEMBER returned\n");
194. return CPPvariables.QI_PTR_MEMBER;
195. }
196. case OPERATOR:
197. // Like A::operator, ::operator, or operator
198. //printf("support.cpp qualifiedItemIs QI_OPERATOR returned\n");
199. return CPPvariables.QI_OPERATOR;
200. default:
201. // Something that neither starts with :: or ID, or
202. // a :: not followed by ID, operator, ~, or *
203. //printf("support.cpp qualifiedItemIs QI_INVALID(6) returned\n");
204. return CPPvariables.QI_INVALID;
205. }
206. }
207.
208. // Skip over <...>. This correctly handles nested <> and (), e.g:
209. // <T>
210. // < (i>3) >
211. // < T2<...> >
212. // but not
213. // < i>3 >
214. //
215. // On input, kInOut is the index of the "<"
216. // On output, if the return is true, then
217. // kInOut is the index of the token after ">"
218. // else
219. // kInOut is unchanged
220.
221. public int skipTemplateQualifiers(int kInOut) throws TokenStreamException
222. {
223. // Start after "<"
224. int k = kInOut + 1;
225. int value;
226. while (LT(k).getType() != GREATERTHAN) // scan to end of <...>
227. {
228. switch (LT(k).getType())
229. {
230. case EOF:
231. return kInOut;
232. case LESSTHAN:
233. value=skipTemplateQualifiers(k);
234. if (value==k)
235. {
236. return kInOut;
237. }
238. else
239. k=value;
240. break;
241. case LPAREN:
242. value=skipNestedParens(k);
243. if (value==k)
244. {
245. return kInOut;
246. }
247. else
248. k=value;
249. break;
250. default:
251. k++; // skip everything else
252. break;
253. }
254. if (k > CPPvariables.MAX_TEMPLATE_TOKEN_SCAN)
255. {
256. return kInOut;
257. }
258. }
259.
260. // Update output argument to point past ">"
261. kInOut = k + 1;
262. return kInOut;
263. }
264.
265. // Skip over (...). This correctly handles nested (), e.g:
266. // (i>3, (i>5))
267. //
268. // On input, kInOut is the index of the "("
269. // On output, if the return is true, then
270. // kInOut is the index of the token after ")"
271. // else
272. // kInOut is unchanged
273. public int skipNestedParens(int kInOut) throws TokenStreamException
274. {
275. // Start after "("
276. int k = kInOut + 1;
277. int value;
278. while (LT(k).getType() != RPAREN) // scan to end of (...)
279. {
280. switch (LT(k).getType())
281. {
282. case EOF:
283. return kInOut;
284. case LPAREN:
285. value=skipNestedParens(k);
286. if (value==k)
287. {
288. return kInOut;
289. }
290. else
291. k=value;
292. break;
293. default:
294. k++; // skip everything else
295. break;
296. }
297. if (k > CPPvariables.MAX_TEMPLATE_TOKEN_SCAN)
298. {
299. return kInOut;
300. }
301. }
302. // Update output argument to point past ")"
303. kInOut = k + 1;
304. return kInOut;
305. }
306.
307. // Return true if "::blah" or "fu::bar<args>::..." found.
308. public boolean scopedItem(int k) throws TokenStreamException
309. {
310. //printf("support.cpp scopedItem k %d\n",k);
311. return (LT(k).getType()==SCOPE ||
312. (LT(k).getType()==ID && !finalQualifier(k)));
313. }
314.
315. // Return true if ID<...> or ID is last item in qualified item list.
316. // Return false if LT(k) is not an ID.
317. // ID must be a type to check for ID<...>,
318. // or else we would get confused by "i<3"
319. public boolean finalQualifier(int k) throws TokenStreamException
320. {
321. if (LT(k).getType()==ID)
322. {
323. if ((isTypeName(LT(k).getText())) && (LT(k+1).getType()==LESSTHAN))
324. {
325. // Starts with "T<". Skip <...>
326. k++;
327. k=skipTemplateQualifiers(k);
328. }
329. else
330. {
331. // skip ID;
332. k++;
333. }
334. return (LT(k).getType() != SCOPE );
335. }
336. else
337. { // not an ID
338. return false;
339. }
340. }
341.
342. /*
343. * Return true if 's' can pose as a type name
344. */
345. public boolean isTypeName(String s)
346. {
347. String type="";
348. if (!symbols.containsKey(s))
349. {
350. //printf("support.cpp isTypeName %s not found\n",s);
351. return false;
352. }
353. else
354. type=(String) symbols.get(s);
355. if (type.equals(CPPvariables.OT_TYPE_DEF)||
356. type.equals(CPPvariables.OT_ENUM)||
357. type.equals(CPPvariables.OT_CLASS)||
358. type.equals(CPPvariables.OT_STRUCT)||
359. type.equals(CPPvariables.OT_UNION))
360. {
361. return true;
362. }
363. return false;
364. }
365.
366. public void declaratorID(String id, java.util.BitSet qi)
367. {
368. if ((qi.equals(CPPvariables.QI_TYPE)) || (_td)) // Check for type declaration
369. {
370. if (!symbols.containsKey(id))
371. symbols.put(id, CPPvariables.OT_TYPE_DEF);
372. }
373. }
374.
375. protected CPPParser(TokenBuffer tokenBuf, int k) {
376. super(tokenBuf,k);
377. tokenNames = _tokenNames;
378. }
379.
380. public CPPParser(TokenBuffer tokenBuf) {
381. this(tokenBuf,2);
382. }
383.
384. protected CPPParser(TokenStream lexer, int k) {
385. super(lexer,k);
386. tokenNames = _tokenNames;
387. }
388.
389. public CPPParser(TokenStream lexer) {
390. this(lexer,2);
391. }
392.
393. public CPPParser(ParserSharedInputState state) {
394. super(state,2);
395. tokenNames = _tokenNames;
396. }
397.
398. public final void translation_unit(
399. Modeler modeler
400. ) throws RecognitionException, TokenStreamException {
401.
402.
403. if(!symbols.containsKey("std"))
404. symbols.put("std",CPPvariables.OT_TYPE_DEF);
405. m = modeler;
406.
407.
408. if ( inputState.guessing==0 ) {
409. m.beginTranslationUnit();
410. }
411. {
412. int _cnt3=0;
413. _loop3:
414. do {
415. if ((_tokenSet_0.member(LA(1)))) {
416. external_declaration();
417. }
418. else {
419. if ( _cnt3>=1 ) { break _loop3; } else {throw new NoViableAltException(LT(1), getFilename());}
420. }
421.
422. _cnt3++;
423. } while (true);
424. }
425. match(Token.EOF_TYPE);
426. if ( inputState.guessing==0 ) {
427. m.endTranslationUnit();
428. }
429. }
430.
431. public final void external_declaration() throws RecognitionException, TokenStreamException {
432.
433. String s="";
434.
435. {
436. switch ( LA(1)) {
437. case LITERAL_namespace:
438. {
439. decl_namespace();
440. break;
441. }
442. case SEMICOLON:
443. {
444. match(SEMICOLON);
445. break;
446. }
447. default:
448. boolean synPredMatched7 = false;
449. if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
450. int _m7 = mark();
451. synPredMatched7 = true;
452. inputState.guessing++;
453. try {
454. {
455. match(LITERAL_template);
456. match(LESSTHAN);
457. match(GREATERTHAN);
458. }
459. }
460. catch (RecognitionException pe) {
461. synPredMatched7 = false;
462. }
463. rewind(_m7);
464. inputState.guessing--;
465. }
466. if ( synPredMatched7 ) {
467. match(LITERAL_template);
468. match(LESSTHAN);
469. match(GREATERTHAN);
470. declaration();
471. }
472. else {
473. boolean synPredMatched10 = false;
474. if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
475. int _m10 = mark();
476. synPredMatched10 = true;
477. inputState.guessing++;
478. try {
479. {
480. {
481. switch ( LA(1)) {
482. case LITERAL_typedef:
483. {
484. match(LITERAL_typedef);
485. break;
486. }
487. case LITERAL_class:
488. case LITERAL_struct:
489. case LITERAL_union:
490. {
491. break;
492. }
493. default:
494. {
495. throw new NoViableAltException(LT(1), getFilename());
496. }
497. }
498. }
499. class_head();
500. }
501. }
502. catch (RecognitionException pe) {
503. synPredMatched10 = false;
504. }
505. rewind(_m10);
506. inputState.guessing--;
507. }
508. if ( synPredMatched10 ) {
509. declaration();
510. }
511. else {
512. boolean synPredMatched12 = false;
513. if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
514. int _m12 = mark();
515. synPredMatched12 = true;
516. inputState.guessing++;
517. try {
518. {
519. template_head();
520. class_head();
521. }
522. }
523. catch (RecognitionException pe) {
524. synPredMatched12 = false;
525. }
526. rewind(_m12);
527. inputState.guessing--;
528. }
529. if ( synPredMatched12 ) {
530. template_head();
531. declaration();
532. }
533. else {
534. boolean synPredMatched15 = false;
535. if (((LA(1)==LITERAL_enum) && (LA(2)==ID||LA(2)==LCURLY))) {
536. int _m15 = mark();
537. synPredMatched15 = true;
538. inputState.guessing++;
539. try {
540. {
541. match(LITERAL_enum);
542. {
543. switch ( LA(1)) {
544. case ID:
545. {
546. match(ID);
547. break;
548. }
549. case LCURLY:
550. {
551. break;
552. }
553. default:
554. {
555. throw new NoViableAltException(LT(1), getFilename());
556. }
557. }
558. }
559. match(LCURLY);
560. }
561. }
562. catch (RecognitionException pe) {
563. synPredMatched15 = false;
564. }
565. rewind(_m15);
566. inputState.guessing--;
567. }
568. if ( synPredMatched15 ) {
569. enum_specifier();
570. {
571. switch ( LA(1)) {
572. case ID:
573. case LITERAL__stdcall:
574. case LITERAL___stdcall:
575. case LPAREN:
576. case OPERATOR:
577. case LITERAL_this:
578. case LITERAL_true:
579. case LITERAL_false:
580. case STAR:
581. case AMPERSAND:
582. case TILDE:
583. case SCOPE:
584. case LITERAL__cdecl:
585. case LITERAL___cdecl:
586. case LITERAL__near:
587. case LITERAL___near:
588. case LITERAL__far:
589. case LITERAL___far:
590. case LITERAL___interrupt:
591. case LITERAL_pascal:
592. case LITERAL__pascal:
593. case LITERAL___pascal:
594. {
595. init_declarator_list();
596. break;
597. }
598. case SEMICOLON:
599. {
600. break;
601. }
602. default:
603. {
604. throw new NoViableAltException(LT(1), getFilename());
605. }
606. }
607. }
608. match(SEMICOLON);
609. }
610. else {
611. boolean synPredMatched19 = false;
612. if (((_tokenSet_3.member(LA(1))) && (_tokenSet_4.member(LA(2))))) {
613. int _m19 = mark();
614. synPredMatched19 = true;
615. inputState.guessing++;
616. try {
617. {
618. {
619. switch ( LA(1)) {
620. case LITERAL_template:
621. {
622. template_head();
623. break;
624. }
625. case ID:
626. case LITERAL_inline:
627. case LITERAL__inline:
628. case LITERAL___inline:
629. case LITERAL_virtual:
630. case TILDE:
631. case SCOPE:
632. {
633. break;
634. }
635. default:
636. {
637. throw new NoViableAltException(LT(1), getFilename());
638. }
639. }
640. }
641. dtor_head();
642. match(LCURLY);
643. }
644. }
645. catch (RecognitionException pe) {
646. synPredMatched19 = false;
647. }
648. rewind(_m19);
649. inputState.guessing--;
650. }
651. if ( synPredMatched19 ) {
652. {
653. switch ( LA(1)) {
654. case LITERAL_template:
655. {
656. template_head();
657. break;
658. }
659. case ID:
660. case LITERAL_inline:
661. case LITERAL__inline:
662. case LITERAL___inline:
663. case LITERAL_virtual:
664. case TILDE:
665. case SCOPE:
666. {
667. break;
668. }
669. default:
670. {
671. throw new NoViableAltException(LT(1), getFilename());
672. }
673. }
674. }
675. dtor_head();
676. dtor_body();
677. }
678. else {
679. boolean synPredMatched23 = false;
680. if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
681. int _m23 = mark();
682. synPredMatched23 = true;
683. inputState.guessing++;
684. try {
685. {
686. {
687. if ((true) && (true)) {
688. ctor_decl_spec();
689. }
690. else {
691. }
692.
693. }
694. if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
695. throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
696. }
697. }
698. catch (RecognitionException pe) {
699. synPredMatched23 = false;
700. }
701. rewind(_m23);
702. inputState.guessing--;
703. }
704. if ( synPredMatched23 ) {
705. ctor_definition();
706. }
707. else {
708. boolean synPredMatched26 = false;
709. if (((_tokenSet_7.member(LA(1))) && (_tokenSet_8.member(LA(2))))) {
710. int _m26 = mark();
711. synPredMatched26 = true;
712. inputState.guessing++;
713. try {
714. {
715. {
716. switch ( LA(1)) {
717. case LITERAL_inline:
718. {
719. match(LITERAL_inline);
720. break;
721. }
722. case ID:
723. case OPERATOR:
724. case SCOPE:
725. {
726. break;
727. }
728. default:
729. {
730. throw new NoViableAltException(LT(1), getFilename());
731. }
732. }
733. }
734. scope_override();
735. conversion_function_decl_or_def();
736. }
737. }
738. catch (RecognitionException pe) {
739. synPredMatched26 = false;
740. }
741. rewind(_m26);
742. inputState.guessing--;
743. }
744. if ( synPredMatched26 ) {
745. {
746. switch ( LA(1)) {
747. case LITERAL_inline:
748. {
749. match(LITERAL_inline);
750. break;
751. }
752. case ID:
753. case OPERATOR:
754. case SCOPE:
755. {
756. break;
757. }
758. default:
759. {
760. throw new NoViableAltException(LT(1), getFilename());
761. }
762. }
763. }
764. s=scope_override();
765. conversion_function_decl_or_def();
766. }
767. else {
768. boolean synPredMatched29 = false;
769. if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
770. int _m29 = mark();
771. synPredMatched29 = true;
772. inputState.guessing++;
773. try {
774. {
775. declaration_specifiers();
776. function_declarator();
777. match(SEMICOLON);
778. }
779. }
780. catch (RecognitionException pe) {
781. synPredMatched29 = false;
782. }
783. rewind(_m29);
784. inputState.guessing--;
785. }
786. if ( synPredMatched29 ) {
787. declaration();
788. }
789. else {
790. boolean synPredMatched31 = false;
791. if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
792. int _m31 = mark();
793. synPredMatched31 = true;
794. inputState.guessing++;
795. try {
796. {
797. declaration_specifiers();
798. function_declarator();
799. match(LCURLY);
800. }
801. }
802. catch (RecognitionException pe) {
803. synPredMatched31 = false;
804. }
805. rewind(_m31);
806. inputState.guessing--;
807. }
808. if ( synPredMatched31 ) {
809. if ( inputState.guessing==0 ) {
810. m.beginFunctionDefinition();
811. }
812. function_definition();
813. if ( inputState.guessing==0 ) {
814. m.endFunctionDefinition();
815. }
816. }
817. else {
818. boolean synPredMatched33 = false;
819. if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
820. int _m33 = mark();
821. synPredMatched33 = true;
822. inputState.guessing++;
823. try {
824. {
825. declaration_specifiers();
826. function_declarator();
827. declaration();
828. }
829. }
830. catch (RecognitionException pe) {
831. synPredMatched33 = false;
832. }
833. rewind(_m33);
834. inputState.guessing--;
835. }
836. if ( synPredMatched33 ) {
837. function_definition();
838. }
839. else {
840. boolean synPredMatched36 = false;
841. if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
842. int _m36 = mark();
843. synPredMatched36 = true;
844. inputState.guessing++;
845. try {
846. {
847. template_head();
848. declaration_specifiers();
849. {
850. switch ( LA(1)) {
851. case ID:
852. case LITERAL__stdcall:
853. case LITERAL___stdcall:
854. case LPAREN:
855. case OPERATOR:
856. case LITERAL_this:
857. case LITERAL_true:
858. case LITERAL_false:
859. case STAR:
860. case AMPERSAND:
861. case TILDE:
862. case SCOPE:
863. case LITERAL__cdecl:
864. case LITERAL___cdecl:
865. case LITERAL__near:
866. case LITERAL___near:
867. case LITERAL__far:
868. case LITERAL___far:
869. case LITERAL___interrupt:
870. case LITERAL_pascal:
871. case LITERAL__pascal:
872. case LITERAL___pascal:
873. {
874. init_declarator_list();
875. break;
876. }
877. case SEMICOLON:
878. {
879. break;
880. }
881. default:
882. {
883. throw new NoViableAltException(LT(1), getFilename());
884. }
885. }
886. }
887. match(SEMICOLON);
888. }
889. }
890. catch (RecognitionException pe) {
891. synPredMatched36 = false;
892. }
893. rewind(_m36);
894. inputState.guessing--;
895. }
896. if ( synPredMatched36 ) {
897. template_head();
898. declaration_specifiers();
899. {
900. switch ( LA(1)) {
901. case ID:
902. case LITERAL__stdcall:
903. case LITERAL___stdcall:
904. case LPAREN:
905. case OPERATOR:
906. case LITERAL_this:
907. case LITERAL_true:
908. case LITERAL_false:
909. case STAR:
910. case AMPERSAND:
911. case TILDE:
912. case SCOPE:
913. case LITERAL__cdecl:
914. case LITERAL___cdecl:
915. case LITERAL__near:
916. case LITERAL___near:
917. case LITERAL__far:
918. case LITERAL___far:
919. case LITERAL___interrupt:
920. case LITERAL_pascal:
921. case LITERAL__pascal:
922. case LITERAL___pascal:
923. {
924. init_declarator_list();
925. break;
926. }
927. case SEMICOLON:
928. {
929. break;
930. }
931. default:
932. {
933. throw new NoViableAltException(LT(1), getFilename());
934. }
935. }
936. }
937. match(SEMICOLON);
938. }
939. else if ((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN)) {
940. template_head();
941. {
942. boolean synPredMatched40 = false;
943. if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
944. int _m40 = mark();
945. synPredMatched40 = true;
946. inputState.guessing++;
947. try {
948. {
949. ctor_decl_spec();
950. if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
951. throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
952. }
953. }
954. catch (RecognitionException pe) {
955. synPredMatched40 = false;
956. }
957. rewind(_m40);
958. inputState.guessing--;
959. }
960. if ( synPredMatched40 ) {
961. ctor_definition();
962. }
963. else {
964. boolean synPredMatched42 = false;
965. if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
966. int _m42 = mark();
967. synPredMatched42 = true;
968. inputState.guessing++;
969. try {
970. {
971. declaration_specifiers();
972. function_declarator();
973. match(SEMICOLON);
974. }
975. }
976. catch (RecognitionException pe) {
977. synPredMatched42 = false;
978. }
979. rewind(_m42);
980. inputState.guessing--;
981. }
982. if ( synPredMatched42 ) {
983. declaration();
984. }
985. else {
986. boolean synPredMatched44 = false;
987. if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
988. int _m44 = mark();
989. synPredMatched44 = true;
990. inputState.guessing++;
991. try {
992. {
993. declaration_specifiers();
994. function_declarator();
995. match(LCURLY);
996. }
997. }
998. catch (RecognitionException pe) {
999. synPredMatched44 = false;
1000. }
1001. rewind(_m44);
1002. inputState.guessing--;
1003. }
1004. if ( synPredMatched44 ) {
1005. function_definition();
1006. }
1007. else {
1008. throw new NoViableAltException(LT(1), getFilename());
1009. }
1010. }}
1011. }
1012. }
1013. else if ((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2)))) {
1014. declaration();
1015. }
1016. else {
1017. throw new NoViableAltException(LT(1), getFilename());
1018. }
1019. }}}}}}}}}}}
1020. }
1021. }
1022.
1023. public final void declaration() throws RecognitionException, TokenStreamException {
1024.
1025.
1026. boolean synPredMatched106 = false;
1027. if (((LA(1)==LITERAL_extern) && (LA(2)==StringLiteral))) {
1028. int _m106 = mark();
1029. synPredMatched106 = true;
1030. inputState.guessing++;
1031. try {
1032. {
1033. match(LITERAL_extern);
1034. match(StringLiteral);
1035. }
1036. }
1037. catch (RecognitionException pe) {
1038. synPredMatched106 = false;
1039. }
1040. rewind(_m106);
1041. inputState.guessing--;
1042. }
1043. if ( synPredMatched106 ) {
1044. linkage_specification();
1045. }
1046. else if ((_tokenSet_11.member(LA(1))) && (_tokenSet_12.member(LA(2)))) {
1047. declaration_specifiers();
1048. {
1049. switch ( LA(1)) {
1050. case ID:
1051. case COMMA:
1052. case LITERAL__stdcall:
1053. case LITERAL___stdcall:
1054. case LPAREN:
1055. case OPERATOR:
1056. case LITERAL_this:
1057. case LITERAL_true:
1058. case LITERAL_false:
1059. case STAR:
1060. case AMPERSAND:
1061. case TILDE:
1062. case SCOPE:
1063. case LITERAL__cdecl:
1064. case LITERAL___cdecl:
1065. case LITERAL__near:
1066. case LITERAL___near:
1067. case LITERAL__far:
1068. case LITERAL___far:
1069. case LITERAL___interrupt:
1070. case LITERAL_pascal:
1071. case LITERAL__pascal:
1072. case LITERAL___pascal:
1073. {
1074. {
1075. switch ( LA(1)) {
1076. case COMMA:
1077. {
1078. match(COMMA);
1079. break;
1080. }
1081. case ID:
1082. case LITERAL__stdcall:
1083. case LITERAL___stdcall:
1084. case LPAREN:
1085. case OPERATOR:
1086. case LITERAL_this:
1087. case LITERAL_true:
1088. case LITERAL_false:
1089. case STAR:
1090. case AMPERSAND:
1091. case TILDE:
1092. case SCOPE:
1093. case LITERAL__cdecl:
1094. case LITERAL___cdecl:
1095. case LITERAL__near:
1096. case LITERAL___near:
1097. case LITERAL__far:
1098. case LITERAL___far:
1099. case LITERAL___interrupt:
1100. case LITERAL_pascal:
1101. case LITERAL__pascal:
1102. case LITERAL___pascal:
1103. {
1104. break;
1105. }
1106. default:
1107. {
1108. throw new NoViableAltException(LT(1), getFilename());
1109. }
1110. }
1111. }
1112. init_declarator_list();
1113. break;
1114. }
1115. case SEMICOLON:
1116. {
1117. break;
1118. }
1119. default:
1120. {
1121. throw new NoViableAltException(LT(1), getFilename());
1122. }
1123. }
1124. }
1125. match(SEMICOLON);
1126. }
1127. else if ((LA(1)==LITERAL_using)) {
1128. using_declaration();
1129. }
1130. else {
1131. throw new NoViableAltException(LT(1), getFilename());
1132. }
1133.
1134. }
1135.
1136. public final void class_head() throws RecognitionException, TokenStreamException {
1137.
1138.
1139. {
1140. switch ( LA(1)) {
1141. case LITERAL_struct:
1142. {
1143. match(LITERAL_struct);
1144. break;
1145. }
1146. case LITERAL_union:
1147. {
1148. match(LITERAL_union);
1149. break;
1150. }
1151. case LITERAL_class:
1152. {
1153. match(LITERAL_class);
1154. break;
1155. }
1156. default:
1157. {
1158. throw new NoViableAltException(LT(1), getFilename());
1159. }
1160. }
1161. }
1162. {
1163. switch ( LA(1)) {
1164. case ID:
1165. {
1166. match(ID);
1167. {
1168. switch ( LA(1)) {
1169. case LESSTHAN:
1170. {
1171. match(LESSTHAN);
1172. template_argument_list();
1173. match(GREATERTHAN);
1174. break;
1175. }
1176. case LCURLY:
1177. case COLON:
1178. {
1179. break;
1180. }
1181. default:
1182. {
1183. throw new NoViableAltException(LT(1), getFilename());
1184. }
1185. }
1186. }
1187. {
1188. switch ( LA(1)) {
1189. case COLON:
1190. {
1191. base_clause();
1192. break;
1193. }
1194. case LCURLY:
1195. {
1196. break;
1197. }
1198. default:
1199. {
1200. throw new NoViableAltException(LT(1), getFilename());
1201. }
1202. }
1203. }
1204. break;
1205. }
1206. case LCURLY:
1207. {
1208. break;
1209. }
1210. default:
1211. {
1212. throw new NoViableAltException(LT(1), getFilename());
1213. }
1214. }
1215. }
1216. match(LCURLY);
1217. }
1218.
1219. public final void template_head() throws RecognitionException, TokenStreamException {
1220.
1221.
1222. match(LITERAL_template);
1223. match(LESSTHAN);
1224. template_parameter_list();
1225. match(GREATERTHAN);
1226. }
1227.
1228. public final void enum_specifier() throws RecognitionException, TokenStreamException {
1229.
1230. Token id = null;
1231.
1232. match(LITERAL_enum);
1233. {
1234. switch ( LA(1)) {
1235. case LCURLY:
1236. {
1237. match(LCURLY);
1238. enumerator_list();
1239. match(RCURLY);
1240. break;
1241. }
1242. case ID:
1243. {
1244. id = LT(1);
1245. match(ID);
1246. if ( inputState.guessing==0 ) {
1247. if(!symbols.containsKey(id.getText()))
1248. symbols.put(id.getText(),CPPvariables.OT_ENUM);
1249.
1250. }
1251. {
1252. switch ( LA(1)) {
1253. case LCURLY:
1254. {
1255. match(LCURLY);
1256. enumerator_list();
1257. match(RCURLY);
1258. break;
1259. }
1260. case LESSTHAN:
1261. case GREATERTHAN:
1262. case ID:
1263. case SEMICOLON:
1264. case RCURLY:
1265. case ASSIGNEQUAL:
1266. case COLON:
1267. case COMMA:
1268. case LITERAL__stdcall:
1269. case LITERAL___stdcall:
1270. case LPAREN:
1271. case RPAREN:
1272. case OPERATOR:
1273. case LITERAL_this:
1274. case LITERAL_true:
1275. case LITERAL_false:
1276. case STAR:
1277. case AMPERSAND:
1278. case LSQUARE:
1279. case RSQUARE:
1280. case TILDE:
1281. case ELLIPSIS:
1282. case TIMESEQUAL:
1283. case DIVIDEEQUAL:
1284. case MINUSEQUAL:
1285. case PLUSEQUAL:
1286. case MODEQUAL:
1287. case SHIFTLEFTEQUAL:
1288. case SHIFTRIGHTEQUAL:
1289. case BITWISEANDEQUAL:
1290. case BITWISEXOREQUAL:
1291. case BITWISEOREQUAL:
1292. case QUESTIONMARK:
1293. case OR:
1294. case AND:
1295. case BITWISEOR:
1296. case BITWISEXOR:
1297. case NOTEQUAL:
1298. case EQUAL:
1299. case LESSTHANOREQUALTO:
1300. case GREATERTHANOREQUALTO:
1301. case SHIFTLEFT:
1302. case SHIFTRIGHT:
1303. case PLUS:
1304. case MINUS:
1305. case DIVIDE:
1306. case MOD:
1307. case DOTMBR:
1308. case POINTERTOMBR:
1309. case SCOPE:
1310. case LITERAL__cdecl:
1311. case LITERAL___cdecl:
1312. case LITERAL__near:
1313. case LITERAL___near:
1314. case LITERAL__far:
1315. case LITERAL___far:
1316. case LITERAL___interrupt:
1317. case LITERAL_pascal:
1318. case LITERAL__pascal:
1319. case LITERAL___pascal:
1320. {
1321. break;
1322. }
1323. default:
1324. {
1325. throw new NoViableAltException(LT(1), getFilename());
1326. }
1327. }
1328. }
1329. break;
1330. }
1331. default:
1332. {
1333. throw new NoViableAltException(LT(1), getFilename());
1334. }
1335. }
1336. }
1337. }
1338.
1339. public final void init_declarator_list() throws RecognitionException, TokenStreamException {
1340.
1341.
1342. init_declarator();
1343. {
1344. _loop156:
1345. do {
1346. if ((LA(1)==COMMA)) {
1347. match(COMMA);
1348. init_declarator();
1349. }
1350. else {
1351. break _loop156;
1352. }
1353.
1354. } while (true);
1355. }
1356. }
1357.
1358. public final void dtor_head() throws RecognitionException, TokenStreamException {
1359.
1360.
1361. if ( inputState.guessing==0 ) {
1362. m.beginDtorHead();
1363. }
1364. dtor_decl_spec();
1365. dtor_declarator();
1366. if ( inputState.guessing==0 ) {
1367. m.endDtorHead();
1368. }
1369. }
1370.
1371. public final void dtor_body() throws RecognitionException, TokenStreamException {
1372.
1373.
1374. compound_statement();
1375. }
1376.
1377. public final void ctor_decl_spec() throws RecognitionException, TokenStreamException {
1378.
1379. List declSpecs = new ArrayList();
1380.
1381. {
1382. _loop240:
1383. do {
1384. switch ( LA(1)) {
1385. case LITERAL_inline:
1386. case LITERAL__inline:
1387. case LITERAL___inline:
1388. {
1389. {
1390. switch ( LA(1)) {
1391. case LITERAL_inline:
1392. {
1393. match(LITERAL_inline);
1394. break;
1395. }
1396. case LITERAL__inline:
1397. {
1398. match(LITERAL__inline);
1399. break;
1400. }
1401. case LITERAL___inline:
1402. {
1403. match(LITERAL___inline);
1404. break;
1405. }
1406. default:
1407. {
1408. throw new NoViableAltException(LT(1), getFilename());
1409. }
1410. }
1411. }
1412. if ( inputState.guessing==0 ) {
1413. declSpecs.add("inline");
1414. }
1415. break;
1416. }
1417. case LITERAL_explicit:
1418. {
1419. match(LITERAL_explicit);
1420. if ( inputState.guessing==0 ) {
1421. declSpecs.add("explicit");
1422. }
1423. break;
1424. }
1425. default:
1426. {
1427. break _loop240;
1428. }
1429. }
1430. } while (true);
1431. }
1432. if ( inputState.guessing==0 ) {
1433. m.declarationSpecifiers(declSpecs);
1434. }
1435. }
1436.
1437. public final void ctor_definition() throws RecognitionException, TokenStreamException {
1438.
1439.
1440. if ( inputState.guessing==0 ) {
1441. m.beginCtorDefinition();
1442. }
1443. ctor_head();
1444. ctor_body();
1445. if ( inputState.guessing==0 ) {
1446. m.endCtorDefinition();
1447. }
1448. }
1449.
1450. public final String scope_override() throws RecognitionException, TokenStreamException {
1451. String s="";
1452.
1453. Token id = null;
1454.
1455. String sitem="";
1456.
1457.
1458. {
1459. switch ( LA(1)) {
1460. case SCOPE:
1461. {
1462. match(SCOPE);
1463. if ( inputState.guessing==0 ) {
1464. sitem=sitem+"::";
1465. }
1466. break;
1467. }
1468. case ID:
1469. case OPERATOR:
1470. case LITERAL_this:
1471. case LITERAL_true:
1472. case LITERAL_false:
1473. case STAR:
1474. case TILDE:
1475. {
1476. break;
1477. }
1478. default:
1479. {
1480. throw new NoViableAltException(LT(1), getFilename());
1481. }
1482. }
1483. }
1484. {
1485. _loop457:
1486. do {
1487. if (((LA(1)==ID) && (LA(2)==LESSTHAN||LA(2)==SCOPE))&&(scopedItem(1))) {
1488. id = LT(1);
1489. match(ID);
1490. {
1491. switch ( LA(1)) {
1492. case LESSTHAN:
1493. {
1494. match(LESSTHAN);
1495. template_argument_list();
1496. match(GREATERTHAN);
1497. break;
1498. }
1499. case SCOPE:
1500. {
1501. break;
1502. }
1503. default:
1504. {
1505. throw new NoViableAltException(LT(1), getFilename());
1506. }
1507. }
1508. }
1509. match(SCOPE);
1510. if ( inputState.guessing==0 ) {
1511.
1512. sitem=sitem+id.getText();
1513. sitem=sitem+"::";
1514.
1515. }
1516. }
1517. else {
1518. break _loop457;
1519. }
1520.
1521. } while (true);
1522. }
1523. if ( inputState.guessing==0 ) {
1524. s = sitem;
1525. }
1526. return s;
1527. }
1528.
1529. public final void conversion_function_decl_or_def() throws RecognitionException, TokenStreamExcepti...1530.
1531.
1532. match(OPERATOR);
1533. declaration_specifiers();
1534. {
1535. switch ( LA(1)) {
1536. case STAR:
1537. {
1538. match(STAR);
1539. break;
1540. }
1541. case AMPERSAND:
1542. {
1543. match(AMPERSAND);
1544. break;
1545. }
1546. case LESSTHAN:
1547. case LPAREN:
1548. {
1549. break;
1550. }
1551. default:
1552. {
1553. throw new NoViableAltException(LT(1), getFilename());
1554. }
1555. }
1556. }
1557. {
1558. switch ( LA(1)) {
1559. case LESSTHAN:
1560. {
1561. match(LESSTHAN);
1562. template_parameter_list();
1563. match(GREATERTHAN);
1564. break;
1565. }
1566. case LPAREN:
1567. {
1568. break;
1569. }
1570. default:
1571. {
1572. throw new NoViableAltException(LT(1), getFilename());
1573. }
1574. }
1575. }
1576. match(LPAREN);
1577. {
1578. switch ( LA(1)) {
1579. case LITERAL_typedef:
1580. case LITERAL_enum:
1581. case ID:
1582. case LITERAL_inline:
1583. case LITERAL_extern:
1584. case LITERAL__inline:
1585. case LITERAL___inline:
1586. case LITERAL_virtual:
1587. case LITERAL_explicit:
1588. case LITERAL_friend:
1589. case LITERAL__stdcall:
1590. case LITERAL___stdcall:
1591. case LITERAL__declspec:
1592. case LITERAL___declspec:
1593. case LPAREN:
1594. case LITERAL_typename:
1595. case LITERAL_auto:
1596. case LITERAL_register:
1597. case LITERAL_static:
1598. case LITERAL_mutable:
1599. case LITERAL_const:
1600. case LITERAL_const_cast:
1601. case LITERAL_volatile:
1602. case LITERAL_char:
1603. case LITERAL_wchar_t:
1604. case LITERAL_bool:
1605. case LITERAL_short:
1606. case LITERAL_int:
1607. case 44:
1608. case 45:
1609. case 46:
1610. case LITERAL_long:
1611. case LITERAL_signed:
1612. case LITERAL_unsigned:
1613. case LITERAL_float:
1614. case LITERAL_double:
1615. case LITERAL_void:
1616. case LITERAL_class:
1617. case LITERAL_struct:
1618. case LITERAL_union:
1619. case OPERATOR:
1620. case LITERAL_this:
1621. case LITERAL_true:
1622. case LITERAL_false:
1623. case STAR:
1624. case AMPERSAND:
1625. case TILDE:
1626. case ELLIPSIS:
1627. case SCOPE:
1628. case LITERAL__cdecl:
1629. case LITERAL___cdecl:
1630. case LITERAL__near:
1631. case LITERAL___near:
1632. case LITERAL__far:
1633. case LITERAL___far:
1634. case LITERAL___interrupt:
1635. case LITERAL_pascal:
1636. case LITERAL__pascal:
1637. case LITERAL___pascal:
1638. {
1639. parameter_list();
1640. break;
1641. }
1642. case RPAREN:
1643. {
1644. break;
1645. }
1646. default:
1647. {
1648. throw new NoViableAltException(LT(1), getFilename());
1649. }
1650. }
1651. }
1652. match(RPAREN);
1653. {
1654. switch ( LA(1)) {
1655. case LITERAL_const:
1656. case LITERAL_const_cast:
1657. case LITERAL_volatile:
1658. {
1659. type_qualifier();
1660. break;
1661. }
1662. case LCURLY:
1663. case SEMICOLON:
1664. case LITERAL_throw:
1665. {
1666. break;
1667. }
1668. default:
1669. {
1670. throw new NoViableAltException(LT(1), getFilename());
1671. }
1672. }
1673. }
1674. {
1675. switch ( LA(1)) {
1676. case LITERAL_throw:
1677. {
1678. exception_specification();
1679. break;
1680. }
1681. case LCURLY:
1682. case SEMICOLON:
1683. {
1684. break;
1685. }
1686. default:
1687. {
1688. throw new NoViableAltException(LT(1), getFilename());
1689. }
1690. }
1691. }
1692. {
1693. switch ( LA(1)) {
1694. case LCURLY:
1695. {
1696. compound_statement();
1697. break;
1698. }
1699. case SEMICOLON:
1700. {
1701. match(SEMICOLON);
1702. break;
1703. }
1704. default:
1705. {
1706. throw new NoViableAltException(LT(1), getFilename());
1707. }
1708. }
1709. }
1710. }
1711.
1712. public final void declaration_specifiers() throws RecognitionException, TokenStreamException {
1713.
1714. _td=false; boolean td=false; List declSpecs = new ArrayList();
1715.
1716. {
1717. switch ( LA(1)) {
1718. case LITERAL_typedef:
1719. case LITERAL_enum:
1720. case ID:
1721. case LITERAL_inline:
1722. case LITERAL_extern:
1723. case LITERAL__inline:
1724. case LITERAL___inline:
1725. case LITERAL_virtual:
1726. case LITERAL_explicit:
1727. case LITERAL_friend:
1728. case LITERAL__stdcall:
1729. case LITERAL___stdcall:
1730. case LITERAL__declspec:
1731. case LITERAL___declspec:
1732. case LITERAL_auto:
1733. case LITERAL_register:
1734. case LITERAL_static:
1735. case LITERAL_mutable:
1736. case LITERAL_const:
1737. case LITERAL_const_cast:
1738. case LITERAL_volatile:
1739. case LITERAL_char:
1740. case LITERAL_wchar_t:
1741. case LITERAL_bool:
1742. case LITERAL_short:
1743. case LITERAL_int:
1744. case 44:
1745. case 45:
1746. case 46:
1747. case LITERAL_long:
1748. case LITERAL_signed:
1749. case LITERAL_unsigned:
1750. case LITERAL_float:
1751. case LITERAL_double:
1752. case LITERAL_void:
1753. case LITERAL_class:
1754. case LITERAL_struct:
1755. case LITERAL_union:
1756. case SCOPE:
1757. {
1758. {
1759. _loop119:
1760. do {
1761. switch ( LA(1)) {
1762. case LITERAL_extern:
1763. case LITERAL_auto:
1764. case LITERAL_register:
1765. case LITERAL_static:
1766. case LITERAL_mutable:
1767. {
1768. storage_class_specifier();
1769. break;
1770. }
1771. case LITERAL_const:
1772. case LITERAL_const_cast:
1773. case LITERAL_volatile:
1774. {
1775. type_qualifier();
1776. break;
1777. }
1778. case LITERAL_inline:
1779. case LITERAL__inline:
1780. case LITERAL___inline:
1781. {
1782. {
1783. switch ( LA(1)) {
1784. case LITERAL_inline:
1785. {
1786. match(LITERAL_inline);
1787. break;
1788. }
1789. case LITERAL__inline:
1790. {
1791. match(LITERAL__inline);
1792. break;
1793. }
1794. case LITERAL___inline:
1795. {
1796. match(LITERAL___inline);
1797. break;
1798. }
1799. default:
1800. {
1801. throw new NoViableAltException(LT(1), getFilename());
1802. }
1803. }
1804. }
1805. if ( inputState.guessing==0 ) {
1806. declSpecs.add("inline");
1807. }
1808. break;
1809. }
1810. case LITERAL_virtual:
1811. {
1812. match(LITERAL_virtual);
1813. if ( inputState.guessing==0 ) {
1814. declSpecs.add("virtual");
1815. }
1816. break;
1817. }
1818. case LITERAL_explicit:
1819. {
1820. match(LITERAL_explicit);
1821. if ( inputState.guessing==0 ) {
1822. declSpecs.add("explicit");
1823. }
1824. break;
1825. }
1826. case LITERAL_typedef:
1827. {
1828. match(LITERAL_typedef);
1829. if ( inputState.guessing==0 ) {
1830. td=true; declSpecs.add("typedef");
1831. }
1832. break;
1833. }
1834. case LITERAL_friend:
1835. {
1836. match(LITERAL_friend);
1837. if ( inputState.guessing==0 ) {
1838. declSpecs.add("friend");
1839. }
1840. break;
1841. }
1842. case LITERAL__stdcall:
1843. case LITERAL___stdcall:
1844. {
1845. {
1846. switch ( LA(1)) {
1847. case LITERAL__stdcall:
1848. {
1849. match(LITERAL__stdcall);
1850. break;
1851. }
1852. case LITERAL___stdcall:
1853. {
1854. match(LITERAL___stdcall);
1855. break;
1856. }
1857. default:
1858. {
1859. throw new NoViableAltException(LT(1), getFilename());
1860. }
1861. }
1862. }
1863. if ( inputState.guessing==0 ) {
1864. declSpecs.add("__stdcall");
1865. }
1866. break;
1867. }
1868. default:
1869. if ((LA(1)==LITERAL__declspec||LA(1)==LITERAL___declspec) && (LA(2)==LPAREN)) {
1870. {
1871. switch ( LA(1)) {
1872. case LITERAL__declspec:
1873. {
1874. match(LITERAL__declspec);
1875. break;
1876. }
1877. case LITERAL___declspec:
1878. {
1879. match(LITERAL___declspec);
1880. break;
1881. }
1882. default:
1883. {
1884. throw new NoViableAltException(LT(1), getFilename());
1885. }
1886. }
1887. }
1888. match(LPAREN);
1889. match(ID);
1890. match(RPAREN);
1891. }
1892. else {
1893. break _loop119;
1894. }
1895. }
1896. } while (true);
1897. }
1898. if ( inputState.guessing==0 ) {
1899. if (!declSpecs.isEmpty()) m.declarationSpecifiers(declSpecs);
1900. }
1901. type_specifier();
1902. break;
1903. }
1904. case LITERAL_typename:
1905. {
1906. match(LITERAL_typename);
1907. if ( inputState.guessing==0 ) {
1908. td=true;
1909. }
1910. direct_declarator();
1911. break;
1912. }
1913. default:
1914. {
1915. throw new NoViableAltException(LT(1), getFilename());
1916. }
1917. }
1918. }
1919. if ( inputState.guessing==0 ) {
1920. _td=td;
1921. }
1922. }
1923.
1924. public final void function_declarator() throws RecognitionException, TokenStreamException {
1925.
1926.
1927. boolean synPredMatched227 = false;
1928. if (((_tokenSet_13.member(LA(1))) && (_tokenSet_14.member(LA(2))))) {
1929. int _m227 = mark();
1930. synPredMatched227 = true;
1931. inputState.guessing++;
1932. try {
1933. {
1934. ptr_operator();
1935. }
1936. }
1937. catch (RecognitionException pe) {
1938. synPredMatched227 = false;
1939. }
1940. rewind(_m227);
1941. inputState.guessing--;
1942. }
1943. if ( synPredMatched227 ) {
1944. ptr_operator();
1945. function_declarator();
1946. }
1947. else if ((_tokenSet_15.member(LA(1))) && (_tokenSet_16.member(LA(2)))) {
1948. function_direct_declarator();
1949. }
1950. else {
1951. throw new NoViableAltException(LT(1), getFilename());
1952. }
1953.
1954. }
1955.
1956. public final void function_definition() throws RecognitionException, TokenStreamException {
1957.
1958. java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone(); auxBitSet.or(CPPvariabl...1959.
1960. {
1961. if (((_tokenSet_11.member(LA(1))) && (_tokenSet_17.member(LA(2))))&&(( !(LA(1)==SCOPE||LA(1)==ID) ...1962. declaration_specifiers();
1963. function_declarator();
1964. {
1965. if ((_tokenSet_18.member(LA(1))) && (_tokenSet_19.member(LA(2)))) {
1966. {
1967. _loop100:
1968. do {
1969. if ((_tokenSet_1.member(LA(1)))) {
1970. declaration();
1971. }
1972. else {
1973. break _loop100;
1974. }
1975.
1976. } while (true);
1977. }
1978. }
1979. else if ((LA(1)==LCURLY) && (_tokenSet_20.member(LA(2)))) {
1980. }
1981. else {
1982. throw new NoViableAltException(LT(1), getFilename());
1983. }
1984.
1985. }
1986. compound_statement();
1987. }
1988. else if ((_tokenSet_21.member(LA(1))) && (_tokenSet_22.member(LA(2)))) {
1989. function_declarator();
1990. {
1991. if ((_tokenSet_18.member(LA(1))) && (_tokenSet_19.member(LA(2)))) {
1992. {
1993. _loop103:
1994. do {
1995. if ((_tokenSet_1.member(LA(1)))) {
1996. declaration();
1997. }
1998. else {
1999. break _loop103;
2000. }
2001.
2002. } while (true);
2003. }
2004. }
2005. else if ((LA(1)==LCURLY) && (_tokenSet_20.member(LA(2)))) {
2006. }
2007. else {
2008. throw new NoViableAltException(LT(1), getFilename());
2009. }
2010.
2011. }
2012. compound_statement();
2013. }
2014. else {
2015. throw new NoViableAltException(LT(1), getFilename());
2016. }
2017.
2018. }
2019. }
2020.
2021. public final void decl_namespace() throws RecognitionException, TokenStreamException {
2022.
2023. Token ns = null;
2024. Token ns2 = null;
2025. String qid="";
2026.
2027. match(LITERAL_namespace);
2028. {
2029. if ((LA(1)==ID||LA(1)==LCURLY) && (_tokenSet_23.member(LA(2)))) {
2030. {
2031. switch ( LA(1)) {
2032. case ID:
2033. {
2034. ns = LT(1);
2035. match(ID);
2036. if ( inputState.guessing==0 ) {
2037. _td = true;declaratorID(ns.getText(),CPPvariables.QI_TYPE);
2038. }
2039. break;
2040. }
2041. case LCURLY:
2042. {
2043. break;
2044. }
2045. default:
2046. {
2047. throw new NoViableAltException(LT(1), getFilename());
2048. }
2049. }
2050. }
2051. match(LCURLY);
2052. if ( inputState.guessing==0 ) {
2053. m.enterNamespaceScope(ns.getText());
2054. }
2055. {
2056. _loop49:
2057. do {
2058. if ((_tokenSet_0.member(LA(1)))) {
2059. external_declaration();
2060. }
2061. else {
2062. break _loop49;
2063. }
2064.
2065. } while (true);
2066. }
2067. if ( inputState.guessing==0 ) {
2068. m.exitNamespaceScope();
2069. }
2070. match(RCURLY);
2071. }
2072. else if ((LA(1)==ID) && (LA(2)==ASSIGNEQUAL)) {
2073. ns2 = LT(1);
2074. match(ID);
2075. if ( inputState.guessing==0 ) {
2076. _td=true;declaratorID(ns2.getText(),CPPvariables.QI_TYPE);
2077. }
2078. match(ASSIGNEQUAL);
2079. qid=qualified_id();
2080. match(SEMICOLON);
2081. if ( inputState.guessing==0 ) {
2082. m.makeNamespaceAlias(qid, ns2.getText());
2083. }
2084. }
2085. else {
2086. throw new NoViableAltException(LT(1), getFilename());
2087. }
2088.
2089. }
2090. }
2091.
2092. public final String qualified_id() throws RecognitionException, TokenStreamException {
2093. String q="";
2094.
2095. Token id = null;
2096.
2097. String so="";
2098. String qitem="";
2099.
2100.
2101. so=scope_override();
2102. if ( inputState.guessing==0 ) {
2103. qitem=so;
2104. }
2105. {
2106. switch ( LA(1)) {
2107. case ID:
2108. {
2109. id = LT(1);
2110. match(ID);
2111. {
2112. if ((LA(1)==LESSTHAN) && (_tokenSet_24.member(LA(2)))) {
2113. match(LESSTHAN);
2114. template_argument_list();
2115. match(GREATERTHAN);
2116. }
2117. else if ((_tokenSet_25.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
2118. }
2119. else {
2120. throw new NoViableAltException(LT(1), getFilename());
2121. }
2122.
2123. }
2124. if ( inputState.guessing==0 ) {
2125.
2126. qitem=qitem+id.getText();
2127.
2128. }
2129. break;
2130. }
2131. case OPERATOR:
2132. {
2133. match(OPERATOR);
2134. optor();
2135. if ( inputState.guessing==0 ) {
2136. qitem=qitem+"operator"+"NYI";
2137. }
2138. break;
2139. }
2140. case LITERAL_this:
2141. {
2142. match(LITERAL_this);
2143. break;
2144. }
2145. case LITERAL_true:
2146. case LITERAL_false:
2147. {
2148. {
2149. switch ( LA(1)) {
2150. case LITERAL_true:
2151. {
2152. match(LITERAL_true);
2153. break;
2154. }
2155. case LITERAL_false:
2156. {
2157. match(LITERAL_false);
2158. break;
2159. }
2160. default:
2161. {
2162. throw new NoViableAltException(LT(1), getFilename());
2163. }
2164. }
2165. }
2166. break;
2167. }
2168. default:
2169. {
2170. throw new NoViableAltException(LT(1), getFilename());
2171. }
2172. }
2173. }
2174. if ( inputState.guessing==0 ) {
2175. q = qitem;
2176. }
2177. return q;
2178. }
2179.
2180. public final void member_declaration() throws RecognitionException, TokenStreamException {
2181.
2182. String q="";
2183.
2184. if ( inputState.guessing==0 ) {
2185. m.beginMemberDeclaration();
2186. }
2187. {
2188. switch ( LA(1)) {
2189. case LITERAL_public:
2190. case LITERAL_protected:
2191. case LITERAL_private:
2192. {
2193. access_specifier();
2194. match(COLON);
2195. break;
2196. }
2197. case SEMICOLON:
2198. {
2199. match(SEMICOLON);
2200. break;
2201. }
2202. default:
2203. boolean synPredMatched54 = false;
2204. if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
2205. int _m54 = mark();
2206. synPredMatched54 = true;
2207. inputState.guessing++;
2208. try {
2209. {
2210. {
2211. switch ( LA(1)) {
2212. case LITERAL_typedef:
2213. {
2214. match(LITERAL_typedef);
2215. break;
2216. }
2217. case LITERAL_class:
2218. case LITERAL_struct:
2219. case LITERAL_union:
2220. {
2221. break;
2222. }
2223. default:
2224. {
2225. throw new NoViableAltException(LT(1), getFilename());
2226. }
2227. }
2228. }
2229. class_head();
2230. }
2231. }
2232. catch (RecognitionException pe) {
2233. synPredMatched54 = false;
2234. }
2235. rewind(_m54);
2236. inputState.guessing--;
2237. }
2238. if ( synPredMatched54 ) {
2239. declaration();
2240. }
2241. else {
2242. boolean synPredMatched57 = false;
2243. if (((LA(1)==LITERAL_enum) && (LA(2)==ID||LA(2)==LCURLY))) {
2244. int _m57 = mark();
2245. synPredMatched57 = true;
2246. inputState.guessing++;
2247. try {
2248. {
2249. match(LITERAL_enum);
2250. {
2251. switch ( LA(1)) {
2252. case ID:
2253. {
2254. match(ID);
2255. break;
2256. }
2257. case LCURLY:
2258. {
2259. break;
2260. }
2261. default:
2262. {
2263. throw new NoViableAltException(LT(1), getFilename());
2264. }
2265. }
2266. }
2267. match(LCURLY);
2268. }
2269. }
2270. catch (RecognitionException pe) {
2271. synPredMatched57 = false;
2272. }
2273. rewind(_m57);
2274. inputState.guessing--;
2275. }
2276. if ( synPredMatched57 ) {
2277. enum_specifier();
2278. {
2279. switch ( LA(1)) {
2280. case ID:
2281. case COLON:
2282. case LITERAL__stdcall:
2283. case LITERAL___stdcall:
2284. case LPAREN:
2285. case OPERATOR:
2286. case LITERAL_this:
2287. case LITERAL_true:
2288. case LITERAL_false:
2289. case STAR:
2290. case AMPERSAND:
2291. case TILDE:
2292. case SCOPE:
2293. case LITERAL__cdecl:
2294. case LITERAL___cdecl:
2295. case LITERAL__near:
2296. case LITERAL___near:
2297. case LITERAL__far:
2298. case LITERAL___far:
2299. case LITERAL___interrupt:
2300. case LITERAL_pascal:
2301. case LITERAL__pascal:
2302. case LITERAL___pascal:
2303. {
2304. member_declarator_list();
2305. break;
2306. }
2307. case SEMICOLON:
2308. {
2309. break;
2310. }
2311. default:
2312. {
2313. throw new NoViableAltException(LT(1), getFilename());
2314. }
2315. }
2316. }
2317. match(SEMICOLON);
2318. }
2319. else {
2320. boolean synPredMatched60 = false;
2321. if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
2322. int _m60 = mark();
2323. synPredMatched60 = true;
2324. inputState.guessing++;
2325. try {
2326. {
2327. template_head();
2328. class_head();
2329. }
2330. }
2331. catch (RecognitionException pe) {
2332. synPredMatched60 = false;
2333. }
2334. rewind(_m60);
2335. inputState.guessing--;
2336. }
2337. if ( synPredMatched60 ) {
2338. template_head();
2339. declaration();
2340. }
2341. else {
2342. boolean synPredMatched62 = false;
2343. if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
2344. int _m62 = mark();
2345. synPredMatched62 = true;
2346. inputState.guessing++;
2347. try {
2348. {
2349. ctor_decl_spec();
2350. if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
2351. throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
2352. ctor_declarator();
2353. match(SEMICOLON);
2354. }
2355. }
2356. catch (RecognitionException pe) {
2357. synPredMatched62 = false;
2358. }
2359. rewind(_m62);
2360. inputState.guessing--;
2361. }
2362. if ( synPredMatched62 ) {
2363. ctor_decl_spec();
2364. ctor_declarator();
2365. match(SEMICOLON);
2366. }
2367. else {
2368. boolean synPredMatched65 = false;
2369. if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
2370. int _m65 = mark();
2371. synPredMatched65 = true;
2372. inputState.guessing++;
2373. try {
2374. {
2375. ctor_decl_spec();
2376. if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
2377. throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
2378. ctor_declarator();
2379. {
2380. switch ( LA(1)) {
2381. case COLON:
2382. {
2383. match(COLON);
2384. break;
2385. }
2386. case LCURLY:
2387. {
2388. match(LCURLY);
2389. break;
2390. }
2391. default:
2392. {
2393. throw new NoViableAltException(LT(1), getFilename());
2394. }
2395. }
2396. }
2397. }
2398. }
2399. catch (RecognitionException pe) {
2400. synPredMatched65 = false;
2401. }
2402. rewind(_m65);
2403. inputState.guessing--;
2404. }
2405. if ( synPredMatched65 ) {
2406. ctor_definition();
2407. }
2408. else {
2409. boolean synPredMatched67 = false;
2410. if (((_tokenSet_27.member(LA(1))) && (_tokenSet_4.member(LA(2))))) {
2411. int _m67 = mark();
2412. synPredMatched67 = true;
2413. inputState.guessing++;
2414. try {
2415. {
2416. dtor_head();
2417. match(SEMICOLON);
2418. }
2419. }
2420. catch (RecognitionException pe) {
2421. synPredMatched67 = false;
2422. }
2423. rewind(_m67);
2424. inputState.guessing--;
2425. }
2426. if ( synPredMatched67 ) {
2427. dtor_head();
2428. match(SEMICOLON);
2429. }
2430. else {
2431. boolean synPredMatched69 = false;
2432. if (((_tokenSet_27.member(LA(1))) && (_tokenSet_4.member(LA(2))))) {
2433. int _m69 = mark();
2434. synPredMatched69 = true;
2435. inputState.guessing++;
2436. try {
2437. {
2438. dtor_head();
2439. match(LCURLY);
2440. }
2441. }
2442. catch (RecognitionException pe) {
2443. synPredMatched69 = false;
2444. }
2445. rewind(_m69);
2446. inputState.guessing--;
2447. }
2448. if ( synPredMatched69 ) {
2449. dtor_head();
2450. dtor_body();
2451. }
2452. else {
2453. boolean synPredMatched71 = false;
2454. if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
2455. int _m71 = mark();
2456. synPredMatched71 = true;
2457. inputState.guessing++;
2458. try {
2459. {
2460. declaration_specifiers();
2461. function_declarator();
2462. match(SEMICOLON);
2463. }
2464. }
2465. catch (RecognitionException pe) {
2466. synPredMatched71 = false;
2467. }
2468. rewind(_m71);
2469. inputState.guessing--;
2470. }
2471. if ( synPredMatched71 ) {
2472. if ( inputState.guessing==0 ) {
2473. m.beginFunctionDeclaration();
2474. }
2475. declaration();
2476. if ( inputState.guessing==0 ) {
2477. m.endFunctionDeclaration();
2478. }
2479. }
2480. else {
2481. boolean synPredMatched73 = false;
2482. if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
2483. int _m73 = mark();
2484. synPredMatched73 = true;
2485. inputState.guessing++;
2486. try {
2487. {
2488. declaration_specifiers();
2489. function_declarator();
2490. match(LCURLY);
2491. }
2492. }
2493. catch (RecognitionException pe) {
2494. synPredMatched73 = false;
2495. }
2496. rewind(_m73);
2497. inputState.guessing--;
2498. }
2499. if ( synPredMatched73 ) {
2500. if ( inputState.guessing==0 ) {
2501. m.beginFunctionDefinition();
2502. }
2503. function_definition();
2504. if ( inputState.guessing==0 ) {
2505. m.endFunctionDefinition();
2506. }
2507. }
2508. else {
2509. boolean synPredMatched76 = false;
2510. if (((LA(1)==LITERAL_inline||LA(1)==OPERATOR) && (_tokenSet_28.member(LA(2))))) {
2511. int _m76 = mark();
2512. synPredMatched76 = true;
2513. inputState.guessing++;
2514. try {
2515. {
2516. {
2517. switch ( LA(1)) {
2518. case LITERAL_inline:
2519. {
2520. match(LITERAL_inline);
2521. break;
2522. }
2523. case OPERATOR:
2524. {
2525. break;
2526. }
2527. default:
2528. {
2529. throw new NoViableAltException(LT(1), getFilename());
2530. }
2531. }
2532. }
2533. conversion_function_decl_or_def();
2534. }
2535. }
2536. catch (RecognitionException pe) {
2537. synPredMatched76 = false;
2538. }
2539. rewind(_m76);
2540. inputState.guessing--;
2541. }
2542. if ( synPredMatched76 ) {
2543. {
2544. switch ( LA(1)) {
2545. case LITERAL_inline:
2546. {
2547. match(LITERAL_inline);
2548. break;
2549. }
2550. case OPERATOR:
2551. {
2552. break;
2553. }
2554. default:
2555. {
2556. throw new NoViableAltException(LT(1), getFilename());
2557. }
2558. }
2559. }
2560. conversion_function_decl_or_def();
2561. }
2562. else {
2563. boolean synPredMatched79 = false;
2564. if (((_tokenSet_29.member(LA(1))) && (_tokenSet_30.member(LA(2))))) {
2565. int _m79 = mark();
2566. synPredMatched79 = true;
2567. inputState.guessing++;
2568. try {
2569. {
2570. qualified_id();
2571. match(SEMICOLON);
2572. }
2573. }
2574. catch (RecognitionException pe) {
2575. synPredMatched79 = false;
2576. }
2577. rewind(_m79);
2578. inputState.guessing--;
2579. }
2580. if ( synPredMatched79 ) {
2581. q=qualified_id();
2582. match(SEMICOLON);
2583. }
2584. else {
2585. boolean synPredMatched81 = false;
2586. if (((_tokenSet_11.member(LA(1))) && (_tokenSet_31.member(LA(2))))) {
2587. int _m81 = mark();
2588. synPredMatched81 = true;
2589. inputState.guessing++;
2590. try {
2591. {
2592. declaration_specifiers();
2593. }
2594. }
2595. catch (RecognitionException pe) {
2596. synPredMatched81 = false;
2597. }
2598. rewind(_m81);
2599. inputState.guessing--;
2600. }
2601. if ( synPredMatched81 ) {
2602. declaration_specifiers();
2603. {
2604. switch ( LA(1)) {
2605. case ID:
2606. case COLON:
2607. case LITERAL__stdcall:
2608. case LITERAL___stdcall:
2609. case LPAREN:
2610. case OPERATOR:
2611. case LITERAL_this:
2612. case LITERAL_true:
2613. case LITERAL_false:
2614. case STAR:
2615. case AMPERSAND:
2616. case TILDE:
2617. case SCOPE:
2618. case LITERAL__cdecl:
2619. case LITERAL___cdecl:
2620. case LITERAL__near:
2621. case LITERAL___near:
2622. case LITERAL__far:
2623. case LITERAL___far:
2624. case LITERAL___interrupt:
2625. case LITERAL_pascal:
2626. case LITERAL__pascal:
2627. case LITERAL___pascal:
2628. {
2629. member_declarator_list();
2630. break;
2631. }
2632. case SEMICOLON:
2633. {
2634. break;
2635. }
2636. default:
2637. {
2638. throw new NoViableAltException(LT(1), getFilename());
2639. }
2640. }
2641. }
2642. match(SEMICOLON);
2643. }
2644. else {
2645. boolean synPredMatched84 = false;
2646. if (((_tokenSet_21.member(LA(1))) && (_tokenSet_22.member(LA(2))))) {
2647. int _m84 = mark();
2648. synPredMatched84 = true;
2649. inputState.guessing++;
2650. try {
2651. {
2652. function_declarator();
2653. match(SEMICOLON);
2654. }
2655. }
2656. catch (RecognitionException pe) {
2657. synPredMatched84 = false;
2658. }
2659. rewind(_m84);
2660. inputState.guessing--;
2661. }
2662. if ( synPredMatched84 ) {
2663. function_declarator();
2664. match(SEMICOLON);
2665. }
2666. else if ((_tokenSet_21.member(LA(1))) && (_tokenSet_22.member(LA(2)))) {
2667. function_declarator();
2668. compound_statement();
2669. }
2670. else {
2671. boolean synPredMatched87 = false;
2672. if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
2673. int _m87 = mark();
2674. synPredMatched87 = true;
2675. inputState.guessing++;
2676. try {
2677. {
2678. template_head();
2679. declaration_specifiers();
2680. {
2681. switch ( LA(1)) {
2682. case ID:
2683. case LITERAL__stdcall:
2684. case LITERAL___stdcall:
2685. case LPAREN:
2686. case OPERATOR:
2687. case LITERAL_this:
2688. case LITERAL_true:
2689. case LITERAL_false:
2690. case STAR:
2691. case AMPERSAND:
2692. case TILDE:
2693. case SCOPE:
2694. case LITERAL__cdecl:
2695. case LITERAL___cdecl:
2696. case LITERAL__near:
2697. case LITERAL___near:
2698. case LITERAL__far:
2699. case LITERAL___far:
2700. case LITERAL___interrupt:
2701. case LITERAL_pascal:
2702. case LITERAL__pascal:
2703. case LITERAL___pascal:
2704. {
2705. init_declarator_list();
2706. break;
2707. }
2708. case SEMICOLON:
2709. {
2710. break;
2711. }
2712. default:
2713. {
2714. throw new NoViableAltException(LT(1), getFilename());
2715. }
2716. }
2717. }
2718. match(SEMICOLON);
2719. }
2720. }
2721. catch (RecognitionException pe) {
2722. synPredMatched87 = false;
2723. }
2724. rewind(_m87);
2725. inputState.guessing--;
2726. }
2727. if ( synPredMatched87 ) {
2728. template_head();
2729. declaration_specifiers();
2730. {
2731. switch ( LA(1)) {
2732. case ID:
2733. case LITERAL__stdcall:
2734. case LITERAL___stdcall:
2735. case LPAREN:
2736. case OPERATOR:
2737. case LITERAL_this:
2738. case LITERAL_true:
2739. case LITERAL_false:
2740. case STAR:
2741. case AMPERSAND:
2742. case TILDE:
2743. case SCOPE:
2744. case LITERAL__cdecl:
2745. case LITERAL___cdecl:
2746. case LITERAL__near:
2747. case LITERAL___near:
2748. case LITERAL__far:
2749. case LITERAL___far:
2750. case LITERAL___interrupt:
2751. case LITERAL_pascal:
2752. case LITERAL__pascal:
2753. case LITERAL___pascal:
2754. {
2755. init_declarator_list();
2756. break;
2757. }
2758. case SEMICOLON:
2759. {
2760. break;
2761. }
2762. default:
2763. {
2764. throw new NoViableAltException(LT(1), getFilename());
2765. }
2766. }
2767. }
2768. match(SEMICOLON);
2769. }
2770. else if ((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN)) {
2771. template_head();
2772. {
2773. boolean synPredMatched91 = false;
2774. if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
2775. int _m91 = mark();
2776. synPredMatched91 = true;
2777. inputState.guessing++;
2778. try {
2779. {
2780. ctor_decl_spec();
2781. if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
2782. throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
2783. }
2784. }
2785. catch (RecognitionException pe) {
2786. synPredMatched91 = false;
2787. }
2788. rewind(_m91);
2789. inputState.guessing--;
2790. }
2791. if ( synPredMatched91 ) {
2792. ctor_definition();
2793. }
2794. else {
2795. boolean synPredMatched93 = false;
2796. if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
2797. int _m93 = mark();
2798. synPredMatched93 = true;
2799. inputState.guessing++;
2800. try {
2801. {
2802. declaration_specifiers();
2803. function_declarator();
2804. match(SEMICOLON);
2805. }
2806. }
2807. catch (RecognitionException pe) {
2808. synPredMatched93 = false;
2809. }
2810. rewind(_m93);
2811. inputState.guessing--;
2812. }
2813. if ( synPredMatched93 ) {
2814. declaration();
2815. }
2816. else {
2817. boolean synPredMatched95 = false;
2818. if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
2819. int _m95 = mark();
2820. synPredMatched95 = true;
2821. inputState.guessing++;
2822. try {
2823. {
2824. declaration_specifiers();
2825. function_declarator();
2826. match(LCURLY);
2827. }
2828. }
2829. catch (RecognitionException pe) {
2830. synPredMatched95 = false;
2831. }
2832. rewind(_m95);
2833. inputState.guessing--;
2834. }
2835. if ( synPredMatched95 ) {
2836. function_definition();
2837. }
2838. else if ((LA(1)==OPERATOR) && (_tokenSet_11.member(LA(2)))) {
2839. conversion_function_decl_or_def();
2840. }
2841. else {
2842. throw new NoViableAltException(LT(1), getFilename());
2843. }
2844. }}
2845. }
2846. }
2847. else {
2848. throw new NoViableAltException(LT(1), getFilename());
2849. }
2850. }}}}}}}}}}}}}}
2851. }
2852. if ( inputState.guessing==0 ) {
2853. m.endMemberDeclaration();
2854. }
2855. }
2856.
2857. public final void member_declarator_list() throws RecognitionException, TokenStreamException {
2858.
2859. m.beginMemberDeclaratorList();
2860.
2861. {
2862. member_declarator();
2863. {
2864. switch ( LA(1)) {
2865. case ASSIGNEQUAL:
2866. {
2867. match(ASSIGNEQUAL);
2868. match(OCTALINT);
2869. break;
2870. }
2871. case SEMICOLON:
2872. case COMMA:
2873. {
2874. break;
2875. }
2876. default:
2877. {
2878. throw new NoViableAltException(LT(1), getFilename());
2879. }
2880. }
2881. }
2882. {
2883. _loop180:
2884. do {
2885. if ((LA(1)==COMMA)) {
2886. match(COMMA);
2887. member_declarator();
2888. {
2889. switch ( LA(1)) {
2890. case ASSIGNEQUAL:
2891. {
2892. match(ASSIGNEQUAL);
2893. match(OCTALINT);
2894. break;
2895. }
2896. case SEMICOLON:
2897. case COMMA:
2898. {
2899. break;
2900. }
2901. default:
2902. {
2903. throw new NoViableAltException(LT(1), getFilename());
2904. }
2905. }
2906. }
2907. }
2908. else {
2909. break _loop180;
2910. }
2911.
2912. } while (true);
2913. }
2914. }
2915. if ( inputState.guessing==0 ) {
2916. m.endMemberDeclaratorList();
2917. }
2918. }
2919.
2920. public final void ctor_declarator() throws RecognitionException, TokenStreamException {
2921.
2922. String q="";
2923.
2924. q=qualified_ctor_id();
2925. if ( inputState.guessing==0 ) {
2926. m.qualifiedCtorId(q);
2927. }
2928. match(LPAREN);
2929. {
2930. switch ( LA(1)) {
2931. case LITERAL_typedef:
2932. case LITERAL_enum:
2933. case ID:
2934. case LITERAL_inline:
2935. case LITERAL_extern:
2936. case LITERAL__inline:
2937. case LITERAL___inline:
2938. case LITERAL_virtual:
2939. case LITERAL_explicit:
2940. case LITERAL_friend:
2941. case LITERAL__stdcall:
2942. case LITERAL___stdcall:
2943. case LITERAL__declspec:
2944. case LITERAL___declspec:
2945. case LPAREN:
2946. case LITERAL_typename:
2947. case LITERAL_auto:
2948. case LITERAL_register:
2949. case LITERAL_static:
2950. case LITERAL_mutable:
2951. case LITERAL_const:
2952. case LITERAL_const_cast:
2953. case LITERAL_volatile:
2954. case LITERAL_char:
2955. case LITERAL_wchar_t:
2956. case LITERAL_bool:
2957. case LITERAL_short:
2958. case LITERAL_int:
2959. case 44:
2960. case 45:
2961. case 46:
2962. case LITERAL_long:
2963. case LITERAL_signed:
2964. case LITERAL_unsigned:
2965. case LITERAL_float:
2966. case LITERAL_double:
2967. case LITERAL_void:
2968. case LITERAL_class:
2969. case LITERAL_struct:
2970. case LITERAL_union:
2971. case OPERATOR:
2972. case LITERAL_this:
2973. case LITERAL_true:
2974. case LITERAL_false:
2975. case STAR:
2976. case AMPERSAND:
2977. case TILDE:
2978. case ELLIPSIS:
2979. case SCOPE:
2980. case LITERAL__cdecl:
2981. case LITERAL___cdecl:
2982. case LITERAL__near:
2983. case LITERAL___near:
2984. case LITERAL__far:
2985. case LITERAL___far:
2986. case LITERAL___interrupt:
2987. case LITERAL_pascal:
2988. case LITERAL__pascal:
2989. case LITERAL___pascal:
2990. {
2991. parameter_list();
2992. break;
2993. }
2994. case RPAREN:
2995. {
2996. break;
2997. }
2998. default:
2999. {
3000. throw new NoViableAltException(LT(1), getFilename());
3001. }
3002. }
3003. }
3004. match(RPAREN);
3005. {
3006. switch ( LA(1)) {
3007. case LITERAL_throw:
3008. {
3009. exception_specification();
3010. break;
3011. }
3012. case LCURLY:
3013. case SEMICOLON:
3014. case COLON:
3015. {
3016. break;
3017. }
3018. default:
3019. {
3020. throw new NoViableAltException(LT(1), getFilename());
3021. }
3022. }
3023. }
3024. }
3025.
3026. public final void compound_statement() throws RecognitionException, TokenStreamException {
3027.
3028.
3029. if ( inputState.guessing==0 ) {
3030. m.beginCompoundStatement();
3031. }
3032. match(LCURLY);
3033. {
3034. switch ( LA(1)) {
3035. case LITERAL_typedef:
3036. case LITERAL_enum:
3037. case ID:
3038. case LCURLY:
3039. case SEMICOLON:
3040. case LITERAL_inline:
3041. case LITERAL_extern:
3042. case StringLiteral:
3043. case LITERAL__inline:
3044. case LITERAL___inline:
3045. case LITERAL_virtual:
3046. case LITERAL_explicit:
3047. case LITERAL_friend:
3048. case LITERAL__stdcall:
3049. case LITERAL___stdcall:
3050. case LITERAL__declspec:
3051. case LITERAL___declspec:
3052. case LPAREN:
3053. case LITERAL_typename:
3054. case LITERAL_auto:
3055. case LITERAL_register:
3056. case LITERAL_static:
3057. case LITERAL_mutable:
3058. case LITERAL_const:
3059. case LITERAL_const_cast:
3060. case LITERAL_volatile:
3061. case LITERAL_char:
3062. case LITERAL_wchar_t:
3063. case LITERAL_bool:
3064. case LITERAL_short:
3065. case LITERAL_int:
3066. case 44:
3067. case 45:
3068. case 46:
3069. case LITERAL_long:
3070. case LITERAL_signed:
3071. case LITERAL_unsigned:
3072. case LITERAL_float:
3073. case LITERAL_double:
3074. case LITERAL_void:
3075. case LITERAL_class:
3076. case LITERAL_struct:
3077. case LITERAL_union:
3078. case OPERATOR:
3079. case LITERAL_this:
3080. case LITERAL_true:
3081. case LITERAL_false:
3082. case OCTALINT:
3083. case STAR:
3084. case AMPERSAND:
3085. case TILDE:
3086. case LITERAL_throw:
3087. case LITERAL_case:
3088. case LITERAL_default:
3089. case LITERAL_if:
3090. case LITERAL_switch:
3091. case LITERAL_while:
3092. case LITERAL_do:
3093. case LITERAL_for:
3094. case LITERAL_goto:
3095. case LITERAL_continue:
3096. case LITERAL_break:
3097. case LITERAL_return:
3098. case LITERAL_try:
3099. case LITERAL_using:
3100. case LITERAL__asm:
3101. case LITERAL___asm:
3102. case PLUS:
3103. case MINUS:
3104. case PLUSPLUS:
3105. case MINUSMINUS:
3106. case LITERAL_sizeof:
3107. case SCOPE:
3108. case LITERAL_dynamic_cast:
3109. case LITERAL_static_cast:
3110. case LITERAL_reinterpret_cast:
3111. case NOT:
3112. case LITERAL_new:
3113. case LITERAL_delete:
3114. case DECIMALINT:
3115. case HEXADECIMALINT:
3116. case CharLiteral:
3117. case FLOATONE:
3118. case FLOATTWO:
3119. {
3120. statement_list();
3121. break;
3122. }
3123. case RCURLY:
3124. {
3125. break;
3126. }
3127. default:
3128. {
3129. throw new NoViableAltException(LT(1), getFilename());
3130. }
3131. }
3132. }
3133. match(RCURLY);
3134. if ( inputState.guessing==0 ) {
3135. m.endCompoundStatement();
3136. }
3137. }
3138.
3139. public final void access_specifier() throws RecognitionException, TokenStreamException {
3140.
3141.
3142. switch ( LA(1)) {
3143. case LITERAL_public:
3144. {
3145. match(LITERAL_public);
3146. if ( inputState.guessing==0 ) {
3147. m.accessSpecifier("public");
3148. }
3149. break;
3150. }
3151. case LITERAL_protected:
3152. {
3153. match(LITERAL_protected);
3154. if ( inputState.guessing==0 ) {
3155. m.accessSpecifier("protected");
3156. }
3157. break;
3158. }
3159. case LITERAL_private:
3160. {
3161. match(LITERAL_private);
3162. if ( inputState.guessing==0 ) {
3163. m.accessSpecifier("private");
3164. }
3165. break;
3166. }
3167. default:
3168. {
3169. throw new NoViableAltException(LT(1), getFilename());
3170. }
3171. }
3172. }
3173.
3174. public final void linkage_specification() throws RecognitionException, TokenStreamException {
3175.
3176.
3177. match(LITERAL_extern);
3178. match(StringLiteral);
3179. {
3180. switch ( LA(1)) {
3181. case LCURLY:
3182. {
3183. match(LCURLY);
3184. {
3185. _loop112:
3186. do {
3187. if ((_tokenSet_0.member(LA(1)))) {
3188. external_declaration();
3189. }
3190. else {
3191. break _loop112;
3192. }
3193.
3194. } while (true);
3195. }
3196. match(RCURLY);
3197. break;
3198. }
3199. case LITERAL_typedef:
3200. case LITERAL_enum:
3201. case ID:
3202. case LITERAL_inline:
3203. case LITERAL_extern:
3204. case LITERAL__inline:
3205. case LITERAL___inline:
3206. case LITERAL_virtual:
3207. case LITERAL_explicit:
3208. case LITERAL_friend:
3209. case LITERAL__stdcall:
3210. case LITERAL___stdcall:
3211. case LITERAL__declspec:
3212. case LITERAL___declspec:
3213. case LITERAL_typename:
3214. case LITERAL_auto:
3215. case LITERAL_register:
3216. case LITERAL_static:
3217. case LITERAL_mutable:
3218. case LITERAL_const:
3219. case LITERAL_const_cast:
3220. case LITERAL_volatile:
3221. case LITERAL_char:
3222. case LITERAL_wchar_t:
3223. case LITERAL_bool:
3224. case LITERAL_short:
3225. case LITERAL_int:
3226. case 44:
3227. case 45:
3228. case 46:
3229. case LITERAL_long:
3230. case LITERAL_signed:
3231. case LITERAL_unsigned:
3232. case LITERAL_float:
3233. case LITERAL_double:
3234. case LITERAL_void:
3235. case LITERAL_class:
3236. case LITERAL_struct:
3237. case LITERAL_union:
3238. case LITERAL_using:
3239. case SCOPE:
3240. {
3241. declaration();
3242. break;
3243. }
3244. default:
3245. {
3246. throw new NoViableAltException(LT(1), getFilename());
3247. }
3248. }
3249. }
3250. }
3251.
3252. public final void using_declaration() throws RecognitionException, TokenStreamException {
3253.
3254. String qid="";
3255.
3256. match(LITERAL_using);
3257. {
3258. switch ( LA(1)) {
3259. case LITERAL_namespace:
3260. {
3261. match(LITERAL_namespace);
3262. qid=qualified_id();
3263. break;
3264. }
3265. case ID:
3266. case OPERATOR:
3267. case LITERAL_this:
3268. case LITERAL_true:
3269. case LITERAL_false:
3270. case SCOPE:
3271. {
3272. qid=qualified_id();
3273. break;
3274. }
3275. default:
3276. {
3277. throw new NoViableAltException(LT(1), getFilename());
3278. }
3279. }
3280. }
3281. match(SEMICOLON);
3282. }
3283.
3284. public final void storage_class_specifier() throws RecognitionException, TokenStreamException {
3285.
3286.
3287. switch ( LA(1)) {
3288. case LITERAL_auto:
3289. {
3290. match(LITERAL_auto);
3291. if ( inputState.guessing==0 ) {
3292. m.storageClassSpecifier("auto");
3293. }
3294. break;
3295. }
3296. case LITERAL_register:
3297. {
3298. match(LITERAL_register);
3299. if ( inputState.guessing==0 ) {
3300. m.storageClassSpecifier("register");
3301. }
3302. break;
3303. }
3304. case LITERAL_static:
3305. {
3306. match(LITERAL_static);
3307. if ( inputState.guessing==0 ) {
3308. m.storageClassSpecifier("static");
3309. }
3310. break;
3311. }
3312. case LITERAL_extern:
3313. {
3314. match(LITERAL_extern);
3315. if ( inputState.guessing==0 ) {
3316. m.storageClassSpecifier("extern");
3317. }
3318. break;
3319. }
3320. case LITERAL_mutable:
3321. {
3322. match(LITERAL_mutable);
3323. if ( inputState.guessing==0 ) {
3324. m.storageClassSpecifier("mutable");
3325. }
3326. break;
3327. }
3328. default:
3329. {
3330. throw new NoViableAltException(LT(1), getFilename());
3331. }
3332. }
3333. }
3334.
3335. public final void type_qualifier() throws RecognitionException, TokenStreamException {
3336.
3337.
3338. switch ( LA(1)) {
3339. case LITERAL_const:
3340. case LITERAL_const_cast:
3341. {
3342. {
3343. switch ( LA(1)) {
3344. case LITERAL_const:
3345. {
3346. match(LITERAL_const);
3347. break;
3348. }
3349. case LITERAL_const_cast:
3350. {
3351. match(LITERAL_const_cast);
3352. break;
3353. }
3354. default:
3355. {
3356. throw new NoViableAltException(LT(1), getFilename());
3357. }
3358. }
3359. }
3360. if ( inputState.guessing==0 ) {
3361. m.typeQualifier("const");
3362. }
3363. break;
3364. }
3365. case LITERAL_volatile:
3366. {
3367. match(LITERAL_volatile);
3368. if ( inputState.guessing==0 ) {
3369. m.typeQualifier("volatile");
3370. }
3371. break;
3372. }
3373. default:
3374. {
3375. throw new NoViableAltException(LT(1), getFilename());
3376. }
3377. }
3378. }
3379.
3380. public final void type_specifier() throws RecognitionException, TokenStreamException {
3381.
3382.
3383. switch ( LA(1)) {
3384. case ID:
3385. case LITERAL__declspec:
3386. case LITERAL___declspec:
3387. case LITERAL_char:
3388. case LITERAL_wchar_t:
3389. case LITERAL_bool:
3390. case LITERAL_short:
3391. case LITERAL_int:
3392. case 44:
3393. case 45:
3394. case 46:
3395. case LITERAL_long:
3396. case LITERAL_signed:
3397. case LITERAL_unsigned:
3398. case LITERAL_float:
3399. case LITERAL_double:
3400. case LITERAL_void:
3401. case SCOPE:
3402. {
3403. simple_type_specifier();
3404. break;
3405. }
3406. case LITERAL_class:
3407. case LITERAL_struct:
3408. case LITERAL_union:
3409. {
3410. class_specifier();
3411. break;
3412. }
3413. case LITERAL_enum:
3414. {
3415. enum_specifier();
3416. break;
3417. }
3418. default:
3419. {
3420. throw new NoViableAltException(LT(1), getFilename());
3421. }
3422. }
3423. }
3424.
3425. public final void direct_declarator() throws RecognitionException, TokenStreamException {
3426.
3427. Token dtor = null;
3428. String id="";
3429.
3430. switch ( LA(1)) {
3431. case TILDE:
3432. {
3433. match(TILDE);
3434. dtor = LT(1);
3435. match(ID);
3436. if ( inputState.guessing==0 ) {
3437. declaratorID(dtor.getText(),CPPvariables.QI_DTOR);
3438. }
3439. match(LPAREN);
3440. {
3441. switch ( LA(1)) {
3442. case LITERAL_typedef:
3443. case LITERAL_enum:
3444. case ID:
3445. case LITERAL_inline:
3446. case LITERAL_extern:
3447. case LITERAL__inline:
3448. case LITERAL___inline:
3449. case LITERAL_virtual:
3450. case LITERAL_explicit:
3451. case LITERAL_friend:
3452. case LITERAL__stdcall:
3453. case LITERAL___stdcall:
3454. case LITERAL__declspec:
3455. case LITERAL___declspec:
3456. case LPAREN:
3457. case LITERAL_typename:
3458. case LITERAL_auto:
3459. case LITERAL_register:
3460. case LITERAL_static:
3461. case LITERAL_mutable:
3462. case LITERAL_const:
3463. case LITERAL_const_cast:
3464. case LITERAL_volatile:
3465. case LITERAL_char:
3466. case LITERAL_wchar_t:
3467. case LITERAL_bool:
3468. case LITERAL_short:
3469. case LITERAL_int:
3470. case 44:
3471. case 45:
3472. case 46:
3473. case LITERAL_long:
3474. case LITERAL_signed:
3475. case LITERAL_unsigned:
3476. case LITERAL_float:
3477. case LITERAL_double:
3478. case LITERAL_void:
3479. case LITERAL_class:
3480. case LITERAL_struct:
3481. case LITERAL_union:
3482. case OPERATOR:
3483. case LITERAL_this:
3484. case LITERAL_true:
3485. case LITERAL_false:
3486. case STAR:
3487. case AMPERSAND:
3488. case TILDE:
3489. case ELLIPSIS:
3490. case SCOPE:
3491. case LITERAL__cdecl:
3492. case LITERAL___cdecl:
3493. case LITERAL__near:
3494. case LITERAL___near:
3495. case LITERAL__far:
3496. case LITERAL___far:
3497. case LITERAL___interrupt:
3498. case LITERAL_pascal:
3499. case LITERAL__pascal:
3500. case LITERAL___pascal:
3501. {
3502. parameter_list();
3503. break;
3504. }
3505. case RPAREN:
3506. {
3507. break;
3508. }
3509. default:
3510. {
3511. throw new NoViableAltException(LT(1), getFilename());
3512. }
3513. }
3514. }
3515. match(RPAREN);
3516. break;
3517. }
3518. case LPAREN:
3519. {
3520. match(LPAREN);
3521. declarator();
3522. match(RPAREN);
3523. declarator_suffixes();
3524. break;
3525. }
3526. default:
3527. boolean synPredMatched203 = false;
3528. if (((_tokenSet_29.member(LA(1))) && (_tokenSet_16.member(LA(2))))) {
3529. int _m203 = mark();
3530. synPredMatched203 = true;
3531. inputState.guessing++;
3532. try {
3533. {
3534. qualified_id();
3535. match(LPAREN);
3536. {
3537. switch ( LA(1)) {
3538. case RPAREN:
3539. {
3540. match(RPAREN);
3541. break;
3542. }
3543. case LITERAL_typedef:
3544. case LITERAL_enum:
3545. case ID:
3546. case LITERAL_inline:
3547. case LITERAL_extern:
3548. case LITERAL__inline:
3549. case LITERAL___inline:
3550. case LITERAL_virtual:
3551. case LITERAL_explicit:
3552. case LITERAL_friend:
3553. case LITERAL__stdcall:
3554. case LITERAL___stdcall:
3555. case LITERAL__declspec:
3556. case LITERAL___declspec:
3557. case LITERAL_typename:
3558. case LITERAL_auto:
3559. case LITERAL_register:
3560. case LITERAL_static:
3561. case LITERAL_mutable:
3562. case LITERAL_const:
3563. case LITERAL_const_cast:
3564. case LITERAL_volatile:
3565. case LITERAL_char:
3566. case LITERAL_wchar_t:
3567. case LITERAL_bool:
3568. case LITERAL_short:
3569. case LITERAL_int:
3570. case 44:
3571. case 45:
3572. case 46:
3573. case LITERAL_long:
3574. case LITERAL_signed:
3575. case LITERAL_unsigned:
3576. case LITERAL_float:
3577. case LITERAL_double:
3578. case LITERAL_void:
3579. case LITERAL_class:
3580. case LITERAL_struct:
3581. case LITERAL_union:
3582. case SCOPE:
3583. {
3584. declaration_specifiers();
3585. break;
3586. }
3587. default:
3588. {
3589. throw new NoViableAltException(LT(1), getFilename());
3590. }
3591. }
3592. }
3593. }
3594. }
3595. catch (RecognitionException pe) {
3596. synPredMatched203 = false;
3597. }
3598. rewind(_m203);
3599. inputState.guessing--;
3600. }
3601. if ( synPredMatched203 ) {
3602. id=qualified_id();
3603. if ( inputState.guessing==0 ) {
3604. declaratorID(id,CPPvariables.QI_FUN); m.directDeclarator(id, _td);
3605. }
3606. match(LPAREN);
3607. {
3608. switch ( LA(1)) {
3609. case LITERAL_typedef:
3610. case LITERAL_enum:
3611. case ID:
3612. case LITERAL_inline:
3613. case LITERAL_extern:
3614. case LITERAL__inline:
3615. case LITERAL___inline:
3616. case LITERAL_virtual:
3617. case LITERAL_explicit:
3618. case LITERAL_friend:
3619. case LITERAL__stdcall:
3620. case LITERAL___stdcall:
3621. case LITERAL__declspec:
3622. case LITERAL___declspec:
3623. case LPAREN:
3624. case LITERAL_typename:
3625. case LITERAL_auto:
3626. case LITERAL_register:
3627. case LITERAL_static:
3628. case LITERAL_mutable:
3629. case LITERAL_const:
3630. case LITERAL_const_cast:
3631. case LITERAL_volatile:
3632. case LITERAL_char:
3633. case LITERAL_wchar_t:
3634. case LITERAL_bool:
3635. case LITERAL_short:
3636. case LITERAL_int:
3637. case 44:
3638. case 45:
3639. case 46:
3640. case LITERAL_long:
3641. case LITERAL_signed:
3642. case LITERAL_unsigned:
3643. case LITERAL_float:
3644. case LITERAL_double:
3645. case LITERAL_void:
3646. case LITERAL_class:
3647. case LITERAL_struct:
3648. case LITERAL_union:
3649. case OPERATOR:
3650. case LITERAL_this:
3651. case LITERAL_true:
3652. case LITERAL_false:
3653. case STAR:
3654. case AMPERSAND:
3655. case TILDE:
3656. case ELLIPSIS:
3657. case SCOPE:
3658. case LITERAL__cdecl:
3659. case LITERAL___cdecl:
3660. case LITERAL__near:
3661. case LITERAL___near:
3662. case LITERAL__far:
3663. case LITERAL___far:
3664. case LITERAL___interrupt:
3665. case LITERAL_pascal:
3666. case LITERAL__pascal:
3667. case LITERAL___pascal:
3668. {
3669. parameter_list();
3670. break;
3671. }
3672. case RPAREN:
3673. {
3674. break;
3675. }
3676. default:
3677. {
3678. throw new NoViableAltException(LT(1), getFilename());
3679. }
3680. }
3681. }
3682. match(RPAREN);
3683. {
3684. _loop206:
3685. do {
3686. if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL_volatile))) {
3687. type_qualifier();
3688. }
3689. else {
3690. break _loop206;
3691. }
3692.
3693. } while (true);
3694. }
3695. {
3696. switch ( LA(1)) {
3697. case LITERAL_throw:
3698. {
3699. exception_specification();
3700. break;
3701. }
3702. case LESSTHAN:
3703. case GREATERTHAN:
3704. case ID:
3705. case SEMICOLON:
3706. case RCURLY:
3707. case ASSIGNEQUAL:
3708. case COLON:
3709. case COMMA:
3710. case LITERAL__stdcall:
3711. case LITERAL___stdcall:
3712. case LPAREN:
3713. case RPAREN:
3714. case OPERATOR:
3715. case LITERAL_this:
3716. case LITERAL_true:
3717. case LITERAL_false:
3718. case STAR:
3719. case AMPERSAND:
3720. case LSQUARE:
3721. case RSQUARE:
3722. case TILDE:
3723. case ELLIPSIS:
3724. case TIMESEQUAL:
3725. case DIVIDEEQUAL:
3726. case MINUSEQUAL:
3727. case PLUSEQUAL:
3728. case MODEQUAL:
3729. case SHIFTLEFTEQUAL:
3730. case SHIFTRIGHTEQUAL:
3731. case BITWISEANDEQUAL:
3732. case BITWISEXOREQUAL:
3733. case BITWISEOREQUAL:
3734. case QUESTIONMARK:
3735. case OR:
3736. case AND:
3737. case BITWISEOR:
3738. case BITWISEXOR:
3739. case NOTEQUAL:
3740. case EQUAL:
3741. case LESSTHANOREQUALTO:
3742. case GREATERTHANOREQUALTO:
3743. case SHIFTLEFT:
3744. case SHIFTRIGHT:
3745. case PLUS:
3746. case MINUS:
3747. case DIVIDE:
3748. case MOD:
3749. case DOTMBR:
3750. case POINTERTOMBR:
3751. case SCOPE:
3752. case LITERAL__cdecl:
3753. case LITERAL___cdecl:
3754. case LITERAL__near:
3755. case LITERAL___near:
3756. case LITERAL__far:
3757. case LITERAL___far:
3758. case LITERAL___interrupt:
3759. case LITERAL_pascal:
3760. case LITERAL__pascal:
3761. case LITERAL___pascal:
3762. {
3763. break;
3764. }
3765. default:
3766. {
3767. throw new NoViableAltException(LT(1), getFilename());
3768. }
3769. }
3770. }
3771. }
3772. else {
3773. boolean synPredMatched209 = false;
3774. if (((_tokenSet_29.member(LA(1))) && (_tokenSet_16.member(LA(2))))) {
3775. int _m209 = mark();
3776. synPredMatched209 = true;
3777. inputState.guessing++;
3778. try {
3779. {
3780. qualified_id();
3781. match(LPAREN);
3782. qualified_id();
3783. }
3784. }
3785. catch (RecognitionException pe) {
3786. synPredMatched209 = false;
3787. }
3788. rewind(_m209);
3789. inputState.guessing--;
3790. }
3791. if ( synPredMatched209 ) {
3792. id=qualified_id();
3793. if ( inputState.guessing==0 ) {
3794. declaratorID(id,CPPvariables.QI_VAR);
3795. }
3796. match(LPAREN);
3797. expression_list();
3798. match(RPAREN);
3799. }
3800. else {
3801. boolean synPredMatched211 = false;
3802. if (((_tokenSet_29.member(LA(1))) && (_tokenSet_16.member(LA(2))))) {
3803. int _m211 = mark();
3804. synPredMatched211 = true;
3805. inputState.guessing++;
3806. try {
3807. {
3808. qualified_id();
3809. match(LSQUARE);
3810. }
3811. }
3812. catch (RecognitionException pe) {
3813. synPredMatched211 = false;
3814. }
3815. rewind(_m211);
3816. inputState.guessing--;
3817. }
3818. if ( synPredMatched211 ) {
3819. id=qualified_id();
3820. if ( inputState.guessing==0 ) {
3821.
3822. if (_td==true)
3823. declaratorID(id,CPPvariables.QI_TYPE);
3824. else
3825. declaratorID(id,CPPvariables.QI_VAR);
3826.
3827. }
3828. {
3829. int _cnt214=0;
3830. _loop214:
3831. do {
3832. if ((LA(1)==LSQUARE) && (_tokenSet_32.member(LA(2)))) {
3833. match(LSQUARE);
3834. {
3835. switch ( LA(1)) {
3836. case ID:
3837. case StringLiteral:
3838. case LITERAL__declspec:
3839. case LITERAL___declspec:
3840. case LPAREN:
3841. case LITERAL_const_cast:
3842. case LITERAL_char:
3843. case LITERAL_wchar_t:
3844. case LITERAL_bool:
3845. case LITERAL_short:
3846. case LITERAL_int:
3847. case 44:
3848. case 45:
3849. case 46:
3850. case LITERAL_long:
3851. case LITERAL_signed:
3852. case LITERAL_unsigned:
3853. case LITERAL_float:
3854. case LITERAL_double:
3855. case LITERAL_void:
3856. case OPERATOR:
3857. case LITERAL_this:
3858. case LITERAL_true:
3859. case LITERAL_false:
3860. case OCTALINT:
3861. case STAR:
3862. case AMPERSAND:
3863. case TILDE:
3864. case PLUS:
3865. case MINUS:
3866. case PLUSPLUS:
3867. case MINUSMINUS:
3868. case LITERAL_sizeof:
3869. case SCOPE:
3870. case LITERAL_dynamic_cast:
3871. case LITERAL_static_cast:
3872. case LITERAL_reinterpret_cast:
3873. case NOT:
3874. case LITERAL_new:
3875. case LITERAL_delete:
3876. case DECIMALINT:
3877. case HEXADECIMALINT:
3878. case CharLiteral:
3879. case FLOATONE:
3880. case FLOATTWO:
3881. {
3882. constant_expression();
3883. break;
3884. }
3885. case RSQUARE:
3886. {
3887. break;
3888. }
3889. default:
3890. {
3891. throw new NoViableAltException(LT(1), getFilename());
3892. }
3893. }
3894. }
3895. match(RSQUARE);
3896. }
3897. else {
3898. if ( _cnt214>=1 ) { break _loop214; } else {throw new NoViableAltException(LT(1), getFilenam...3899. }
3900.
3901. _cnt214++;
3902. } while (true);
3903. }
3904. }
3905. else if ((_tokenSet_29.member(LA(1))) && (_tokenSet_33.member(LA(2)))) {
3906. id=qualified_id();
3907. if ( inputState.guessing==0 ) {
3908.
3909. if (_td==true)
3910. declaratorID(id,CPPvariables.QI_TYPE);
3911. else
3912. declaratorID(id,CPPvariables.QI_VAR);
3913. m.directDeclarator(id, _td);
3914.
3915. }
3916. }
3917. else {
3918. throw new NoViableAltException(LT(1), getFilename());
3919. }
3920. }}}
3921. }
3922.
3923. public final void simple_type_specifier() throws RecognitionException, TokenStreamException {
3924.
3925. String s="";
3926. java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone();
3927. auxBitSet.or(CPPvariables.QI_CTOR);
3928. List sts = new ArrayList();
3929.
3930.
3931. {
3932. if (((LA(1)==ID||LA(1)==SCOPE))&&(qualifiedItemIsOneOf(auxBitSet,0))) {
3933. s=qualified_type();
3934. if ( inputState.guessing==0 ) {
3935. sts.add(s); m.simpleTypeSpecifier(sts);
3936. }
3937. }
3938. else if ((_tokenSet_34.member(LA(1)))) {
3939. {
3940. int _cnt129=0;
3941. _loop129:
3942. do {
3943. switch ( LA(1)) {
3944. case LITERAL_char:
3945. {
3946. match(LITERAL_char);
3947. if ( inputState.guessing==0 ) {
3948. sts.add("char");
3949. }
3950. break;
3951. }
3952. case LITERAL_wchar_t:
3953. {
3954. match(LITERAL_wchar_t);
3955. if ( inputState.guessing==0 ) {
3956. sts.add("wchar_t");
3957. }
3958. break;
3959. }
3960. case LITERAL_bool:
3961. {
3962. match(LITERAL_bool);
3963. if ( inputState.guessing==0 ) {
3964. sts.add("bool");
3965. }
3966. break;
3967. }
3968. case LITERAL_short:
3969. {
3970. match(LITERAL_short);
3971. if ( inputState.guessing==0 ) {
3972. sts.add("short");
3973. }
3974. break;
3975. }
3976. case LITERAL_int:
3977. {
3978. match(LITERAL_int);
3979. if ( inputState.guessing==0 ) {
3980. sts.add("int");
3981. }
3982. break;
3983. }
3984. case 44:
3985. case 45:
3986. {
3987. {
3988. switch ( LA(1)) {
3989. case 44:
3990. {
3991. match(44);
3992. break;
3993. }
3994. case 45:
3995. {
3996. match(45);
3997. break;
3998. }
3999. default:
4000. {
4001. throw new NoViableAltException(LT(1), getFilename());
4002. }
4003. }
4004. }
4005. if ( inputState.guessing==0 ) {
4006. sts.add("__int64");
4007. }
4008. break;
4009. }
4010. case 46:
4011. {
4012. match(46);
4013. if ( inputState.guessing==0 ) {
4014. sts.add("__w64");
4015. }
4016. break;
4017. }
4018. case LITERAL_long:
4019. {
4020. match(LITERAL_long);
4021. if ( inputState.guessing==0 ) {
4022. sts.add("long");
4023. }
4024. break;
4025. }
4026. case LITERAL_signed:
4027. {
4028. match(LITERAL_signed);
4029. if ( inputState.guessing==0 ) {
4030. sts.add("signed");
4031. }
4032. break;
4033. }
4034. case LITERAL_unsigned:
4035. {
4036. match(LITERAL_unsigned);
4037. if ( inputState.guessing==0 ) {
4038. sts.add("unsigned");
4039. }
4040. break;
4041. }
4042. case LITERAL_float:
4043. {
4044. match(LITERAL_float);
4045. if ( inputState.guessing==0 ) {
4046. sts.add("float");
4047. }
4048. break;
4049. }
4050. case LITERAL_double:
4051. {
4052. match(LITERAL_double);
4053. if ( inputState.guessing==0 ) {
4054. sts.add("double");
4055. }
4056. break;
4057. }
4058. case LITERAL_void:
4059. {
4060. match(LITERAL_void);
4061. if ( inputState.guessing==0 ) {
4062. sts.add("void");
4063. }
4064. break;
4065. }
4066. case LITERAL__declspec:
4067. case LITERAL___declspec:
4068. {
4069. {
4070. switch ( LA(1)) {
4071. case LITERAL__declspec:
4072. {
4073. match(LITERAL__declspec);
4074. break;
4075. }
4076. case LITERAL___declspec:
4077. {
4078. match(LITERAL___declspec);
4079. break;
4080. }
4081. default:
4082. {
4083. throw new NoViableAltException(LT(1), getFilename());
4084. }
4085. }
4086. }
4087. match(LPAREN);
4088. match(ID);
4089. match(RPAREN);
4090. break;
4091. }
4092. default:
4093. {
4094. if ( _cnt129>=1 ) { break _loop129; } else {throw new NoViableAltException(LT(1), getFilename()...4095. }
4096. }
4097. _cnt129++;
4098. } while (true);
4099. }
4100. if ( inputState.guessing==0 ) {
4101. m.simpleTypeSpecifier(sts);
4102. }
4103. }
4104. else {
4105. throw new NoViableAltException(LT(1), getFilename());
4106. }
4107.
4108. }
4109. }
4110.
4111. public final void class_specifier() throws RecognitionException, TokenStreamException {
4112.
4113. String saveClass="";String id="";String type="";
4114.
4115. {
4116. switch ( LA(1)) {
4117. case LITERAL_class:
4118. {
4119. match(LITERAL_class);
4120. if ( inputState.guessing==0 ) {
4121. type=CPPvariables.OT_CLASS;
4122. }
4123. break;
4124. }
4125. case LITERAL_struct:
4126. {
4127. match(LITERAL_struct);
4128. if ( inputState.guessing==0 ) {
4129. type=CPPvariables.OT_STRUCT;
4130. }
4131. break;
4132. }
4133. case LITERAL_union:
4134. {
4135. match(LITERAL_union);
4136. if ( inputState.guessing==0 ) {
4137. type=CPPvariables.OT_UNION;
4138. }
4139. break;
4140. }
4141. default:
4142. {
4143. throw new NoViableAltException(LT(1), getFilename());
4144. }
4145. }
4146. }
4147. {
4148. switch ( LA(1)) {
4149. case ID:
4150. case OPERATOR:
4151. case LITERAL_this:
4152. case LITERAL_true:
4153. case LITERAL_false:
4154. case SCOPE:
4155. {
4156. id=qualified_id();
4157. {
4158. if ((LA(1)==LCURLY||LA(1)==COLON) && (_tokenSet_35.member(LA(2)))) {
4159. if ( inputState.guessing==0 ) {
4160. saveClass = enclosingClass;
4161. enclosingClass = id;
4162.
4163. }
4164. if ( inputState.guessing==0 ) {
4165. m.beginClassDefinition(type, id);
4166. }
4167. {
4168. switch ( LA(1)) {
4169. case COLON:
4170. {
4171. base_clause();
4172. break;
4173. }
4174. case LCURLY:
4175. {
4176. break;
4177. }
4178. default:
4179. {
4180. throw new NoViableAltException(LT(1), getFilename());
4181. }
4182. }
4183. }
4184. match(LCURLY);
4185. if ( inputState.guessing==0 ) {
4186.
4187. if(!symbols.containsKey(id))
4188. symbols.put(id,type);
4189.
4190. }
4191. {
4192. _loop138:
4193. do {
4194. if ((_tokenSet_36.member(LA(1)))) {
4195. member_declaration();
4196. }
4197. else {
4198. break _loop138;
4199. }
4200.
4201. } while (true);
4202. }
4203. if ( inputState.guessing==0 ) {
4204. m.endClassDefinition();
4205. }
4206. match(RCURLY);
4207. if ( inputState.guessing==0 ) {
4208. enclosingClass = saveClass;
4209. }
4210. }
4211. else if ((_tokenSet_37.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
4212. if ( inputState.guessing==0 ) {
4213.
4214.
4215. String auxName=id;
4216. int pos = auxName.indexOf("::");
4217. while(pos>=0)
4218. {
4219. if(!symbols.containsKey(auxName.substring(0,pos)))
4220. symbols.put(auxName.substring(0,pos),type);
4221. auxName=auxName.substring(pos+2,auxName.length());
4222. pos=auxName.indexOf("::");
4223. }
4224. if(!symbols.containsKey(auxName))
4225. symbols.put(auxName,type);
4226.
4227. }
4228. }
4229. else {
4230. throw new NoViableAltException(LT(1), getFilename());
4231. }
4232.
4233. }
4234. break;
4235. }
4236. case LCURLY:
4237. {
4238. match(LCURLY);
4239. if ( inputState.guessing==0 ) {
4240. id="anonymous";
4241. saveClass = enclosingClass; enclosingClass = "anonymous";
4242. if(!symbols.containsKey(id))
4243. symbols.put(id,type);
4244.
4245. }
4246. {
4247. _loop140:
4248. do {
4249. if ((_tokenSet_36.member(LA(1)))) {
4250. member_declaration();
4251. }
4252. else {
4253. break _loop140;
4254. }
4255.
4256. } while (true);
4257. }
4258. match(RCURLY);
4259. if ( inputState.guessing==0 ) {
4260. enclosingClass = saveClass;
4261. }
4262. break;
4263. }
4264. default:
4265. {
4266. throw new NoViableAltException(LT(1), getFilename());
4267. }
4268. }
4269. }
4270. }
4271.
4272. public final String qualified_type() throws RecognitionException, TokenStreamException {
4273. String q="";
4274.
4275. Token id = null;
4276. String s=""; String qitem="";
4277.
4278. s=scope_override();
4279. id = LT(1);
4280. match(ID);
4281. {
4282. if ((LA(1)==LESSTHAN) && (_tokenSet_24.member(LA(2)))) {
4283. match(LESSTHAN);
4284. template_argument_list();
4285. match(GREATERTHAN);
4286. }
4287. else if ((_tokenSet_25.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
4288. }
4289. else {
4290. throw new NoViableAltException(LT(1), getFilename());
4291. }
4292.
4293. }
4294. if ( inputState.guessing==0 ) {
4295.
4296. qitem=s;
4297. qitem=qitem+id.getText();
4298. q=qitem;
4299.
4300. }
4301. return q;
4302. }
4303.
4304. public final void template_argument_list() throws RecognitionException, TokenStreamException {
4305.
4306.
4307. template_argument();
4308. {
4309. _loop304:
4310. do {
4311. if ((LA(1)==COMMA)) {
4312. match(COMMA);
4313. template_argument();
4314. }
4315. else {
4316. break _loop304;
4317. }
4318.
4319. } while (true);
4320. }
4321. }
4322.
4323. public final void base_clause() throws RecognitionException, TokenStreamException {
4324.
4325.
4326. match(COLON);
4327. base_specifier();
4328. {
4329. _loop170:
4330. do {
4331. if ((LA(1)==COMMA)) {
4332. match(COMMA);
4333. base_specifier();
4334. }
4335. else {
4336. break _loop170;
4337. }
4338.
4339. } while (true);
4340. }
4341. }
4342.
4343. public final void enumerator_list() throws RecognitionException, TokenStreamException {
4344.
4345.
4346. enumerator();
4347. {
4348. _loop146:
4349. do {
4350. if ((LA(1)==COMMA)) {
4351. match(COMMA);
4352. enumerator();
4353. }
4354. else {
4355. break _loop146;
4356. }
4357.
4358. } while (true);
4359. }
4360. }
4361.
4362. public final void enumerator() throws RecognitionException, TokenStreamException {
4363.
4364. Token id = null;
4365.
4366. id = LT(1);
4367. match(ID);
4368. {
4369. switch ( LA(1)) {
4370. case ASSIGNEQUAL:
4371. {
4372. match(ASSIGNEQUAL);
4373. constant_expression();
4374. break;
4375. }
4376. case RCURLY:
4377. case COMMA:
4378. {
4379. break;
4380. }
4381. default:
4382. {
4383. throw new NoViableAltException(LT(1), getFilename());
4384. }
4385. }
4386. }
4387. }
4388.
4389. public final void constant_expression() throws RecognitionException, TokenStreamException {
4390.
4391.
4392. conditional_expression();
4393. }
4394.
4395. public final void optor() throws RecognitionException, TokenStreamException {
4396.
4397.
4398. switch ( LA(1)) {
4399. case LITERAL_new:
4400. {
4401. match(LITERAL_new);
4402. {
4403. if ((LA(1)==LSQUARE) && (LA(2)==RSQUARE)) {
4404. match(LSQUARE);
4405. match(RSQUARE);
4406. }
4407. else if ((_tokenSet_38.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
4408. }
4409. else {
4410. throw new NoViableAltException(LT(1), getFilename());
4411. }
4412.
4413. }
4414. break;
4415. }
4416. case LITERAL_delete:
4417. {
4418. match(LITERAL_delete);
4419. {
4420. if ((LA(1)==LSQUARE) && (LA(2)==RSQUARE)) {
4421. match(LSQUARE);
4422. match(RSQUARE);
4423. }
4424. else if ((_tokenSet_38.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
4425. }
4426. else {
4427. throw new NoViableAltException(LT(1), getFilename());
4428. }
4429.
4430. }
4431. break;
4432. }
4433. case LPAREN:
4434. {
4435. match(LPAREN);
4436. match(RPAREN);
4437. break;
4438. }
4439. case LSQUARE:
4440. {
4441. match(LSQUARE);
4442. match(RSQUARE);
4443. break;
4444. }
4445. case LESSTHAN:
4446. case GREATERTHAN:
4447. case ASSIGNEQUAL:
4448. case COMMA:
4449. case STAR:
4450. case AMPERSAND:
4451. case TILDE:
4452. case TIMESEQUAL:
4453. case DIVIDEEQUAL:
4454. case MINUSEQUAL:
4455. case PLUSEQUAL:
4456. case MODEQUAL:
4457. case SHIFTLEFTEQUAL:
4458. case SHIFTRIGHTEQUAL:
4459. case BITWISEANDEQUAL:
4460. case BITWISEXOREQUAL:
4461. case BITWISEOREQUAL:
4462. case OR:
4463. case AND:
4464. case BITWISEOR:
4465. case BITWISEXOR:
4466. case NOTEQUAL:
4467. case EQUAL:
4468. case LESSTHANOREQUALTO:
4469. case GREATERTHANOREQUALTO:
4470. case SHIFTLEFT:
4471. case SHIFTRIGHT:
4472. case PLUS:
4473. case MINUS:
4474. case DIVIDE:
4475. case MOD:
4476. case POINTERTOMBR:
4477. case PLUSPLUS:
4478. case MINUSMINUS:
4479. case POINTERTO:
4480. case NOT:
4481. {
4482. optor_simple_tokclass();
4483. break;
4484. }
4485. default:
4486. {
4487. throw new NoViableAltException(LT(1), getFilename());
4488. }
4489. }
4490. }
4491.
4492. public final void typeID() throws RecognitionException, TokenStreamException {
4493.
4494.
4495. if (!(isTypeName(LT(1).getText())))
4496. throw new SemanticException("isTypeName(LT(1).getText())");
4497. match(ID);
4498. }
4499.
4500. public final void init_declarator() throws RecognitionException, TokenStreamException {
4501.
4502.
4503. declarator();
4504. {
4505. switch ( LA(1)) {
4506. case ASSIGNEQUAL:
4507. {
4508. match(ASSIGNEQUAL);
4509. initializer();
4510. break;
4511. }
4512. case LPAREN:
4513. {
4514. match(LPAREN);
4515. expression_list();
4516. match(RPAREN);
4517. break;
4518. }
4519. case SEMICOLON:
4520. case COMMA:
4521. {
4522. break;
4523. }
4524. default:
4525. {
4526. throw new NoViableAltException(LT(1), getFilename());
4527. }
4528. }
4529. }
4530. }
4531.
4532. public final void declarator() throws RecognitionException, TokenStreamException {
4533.
4534.
4535. boolean synPredMatched199 = false;
4536. if (((_tokenSet_13.member(LA(1))) && (_tokenSet_39.member(LA(2))))) {
4537. int _m199 = mark();
4538. synPredMatched199 = true;
4539. inputState.guessing++;
4540. try {
4541. {
4542. ptr_operator();
4543. }
4544. }
4545. catch (RecognitionException pe) {
4546. synPredMatched199 = false;
4547. }
4548. rewind(_m199);
4549. inputState.guessing--;
4550. }
4551. if ( synPredMatched199 ) {
4552. ptr_operator();
4553. declarator();
4554. }
4555. else if ((_tokenSet_40.member(LA(1))) && (_tokenSet_41.member(LA(2)))) {
4556. direct_declarator();
4557. }
4558. else {
4559. throw new NoViableAltException(LT(1), getFilename());
4560. }
4561.
4562. }
4563.
4564. public final void initializer() throws RecognitionException, TokenStreamException {
4565.
4566.
4567. if ( inputState.guessing==0 ) {
4568. m.beginInitializer();
4569. }
4570. {
4571. switch ( LA(1)) {
4572. case ID:
4573. case StringLiteral:
4574. case LITERAL__declspec:
4575. case LITERAL___declspec:
4576. case LPAREN:
4577. case LITERAL_const_cast:
4578. case LITERAL_char:
4579. case LITERAL_wchar_t:
4580. case LITERAL_bool:
4581. case LITERAL_short:
4582. case LITERAL_int:
4583. case 44:
4584. case 45:
4585. case 46:
4586. case LITERAL_long:
4587. case LITERAL_signed:
4588. case LITERAL_unsigned:
4589. case LITERAL_float:
4590. case LITERAL_double:
4591. case LITERAL_void:
4592. case OPERATOR:
4593. case LITERAL_this:
4594. case LITERAL_true:
4595. case LITERAL_false:
4596. case OCTALINT:
4597. case STAR:
4598. case AMPERSAND:
4599. case TILDE:
4600. case PLUS:
4601. case MINUS:
4602. case PLUSPLUS:
4603. case MINUSMINUS:
4604. case LITERAL_sizeof:
4605. case SCOPE:
4606. case LITERAL_dynamic_cast:
4607. case LITERAL_static_cast:
4608. case LITERAL_reinterpret_cast:
4609. case NOT:
4610. case LITERAL_new:
4611. case LITERAL_delete:
4612. case DECIMALINT:
4613. case HEXADECIMALINT:
4614. case CharLiteral:
4615. case FLOATONE:
4616. case FLOATTWO:
4617. {
4618. remainder_expression();
4619. break;
4620. }
4621. case LCURLY:
4622. {
4623. match(LCURLY);
4624. initializer();
4625. {
4626. _loop162:
4627. do {
4628. if ((LA(1)==COMMA)) {
4629. match(COMMA);
4630. initializer();
4631. }
4632. else {
4633. break _loop162;
4634. }
4635.
4636. } while (true);
4637. }
4638. match(RCURLY);
4639. break;
4640. }
4641. default:
4642. {
4643. throw new NoViableAltException(LT(1), getFilename());
4644. }
4645. }
4646. }
4647. if ( inputState.guessing==0 ) {
4648. m.endInitializer();
4649. }
4650. }
4651.
4652. public final void expression_list() throws RecognitionException, TokenStreamException {
4653.
4654.
4655. assignment_expression();
4656. {
4657. _loop465:
4658. do {
4659. if ((LA(1)==COMMA)) {
4660. match(COMMA);
4661. assignment_expression();
4662. }
4663. else {
4664. break _loop465;
4665. }
4666.
4667. } while (true);
4668. }
4669. }
4670.
4671. public final void remainder_expression() throws RecognitionException, TokenStreamException {
4672.
4673.
4674. {
4675. boolean synPredMatched355 = false;
4676. if (((_tokenSet_42.member(LA(1))) && (_tokenSet_43.member(LA(2))))) {
4677. int _m355 = mark();
4678. synPredMatched355 = true;
4679. inputState.guessing++;
4680. try {
4681. {
4682. conditional_expression();
4683. {
4684. switch ( LA(1)) {
4685. case COMMA:
4686. {
4687. match(COMMA);
4688. break;
4689. }
4690. case SEMICOLON:
4691. {
4692. match(SEMICOLON);
4693. break;
4694. }
4695. case RPAREN:
4696. {
4697. match(RPAREN);
4698. break;
4699. }
4700. default:
4701. {
4702. throw new NoViableAltException(LT(1), getFilename());
4703. }
4704. }
4705. }
4706. }
4707. }
4708. catch (RecognitionException pe) {
4709. synPredMatched355 = false;
4710. }
4711. rewind(_m355);
4712. inputState.guessing--;
4713. }
4714. if ( synPredMatched355 ) {
4715. assignment_expression();
4716. }
4717. else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_43.member(LA(2)))) {
4718. assignment_expression();
4719. }
4720. else {
4721. throw new NoViableAltException(LT(1), getFilename());
4722. }
4723.
4724. }
4725. }
4726.
4727. public final void base_specifier() throws RecognitionException, TokenStreamException {
4728.
4729. String qt=""; m.beginBaseSpecifier();
4730.
4731. {
4732. switch ( LA(1)) {
4733. case LITERAL_virtual:
4734. {
4735. match(LITERAL_virtual);
4736. {
4737. switch ( LA(1)) {
4738. case LITERAL_public:
4739. case LITERAL_protected:
4740. case LITERAL_private:
4741. {
4742. access_specifier();
4743. break;
4744. }
4745. case ID:
4746. case SCOPE:
4747. {
4748. break;
4749. }
4750. default:
4751. {
4752. throw new NoViableAltException(LT(1), getFilename());
4753. }
4754. }
4755. }
4756. qt=qualified_type();
4757. if ( inputState.guessing==0 ) {
4758. m.baseSpecifier(qt, true);
4759. }
4760. break;
4761. }
4762. case ID:
4763. case SCOPE:
4764. {
4765. qt=qualified_type();
4766. if ( inputState.guessing==0 ) {
4767. m.baseSpecifier(qt, false);
4768. }
4769. break;
4770. }
4771. default:
4772. if (((LA(1) >= LITERAL_public && LA(1) <= LITERAL_private)) && (LA(2)==LITERAL_virtual)) {
4773. access_specifier();
4774. match(LITERAL_virtual);
4775. qt=qualified_type();
4776. if ( inputState.guessing==0 ) {
4777. m.baseSpecifier(qt, true);
4778. }
4779. }
4780. else if (((LA(1) >= LITERAL_public && LA(1) <= LITERAL_private)) && (LA(2)==ID||LA(2)==SCOPE)) {
...4781. access_specifier();
4782. qt=qualified_type();
4783. if ( inputState.guessing==0 ) {
4784. m.baseSpecifier(qt, false);
4785. }
4786. }
4787. else {
4788. throw new NoViableAltException(LT(1), getFilename());
4789. }
4790. }
4791. }
4792. if ( inputState.guessing==0 ) {
4793. m.endBaseSpecifier();
4794. }
4795. }
4796.
4797. public final void member_declarator() throws RecognitionException, TokenStreamException {
4798.
4799. m.beginMemberDeclarator();
4800.
4801. {
4802. boolean synPredMatched185 = false;
4803. if (((LA(1)==ID||LA(1)==COLON) && (_tokenSet_44.member(LA(2))))) {
4804. int _m185 = mark();
4805. synPredMatched185 = true;
4806. inputState.guessing++;
4807. try {
4808. {
4809. {
4810. switch ( LA(1)) {
4811. case ID:
4812. {
4813. match(ID);
4814. break;
4815. }
4816. case COLON:
4817. {
4818. break;
4819. }
4820. default:
4821. {
4822. throw new NoViableAltException(LT(1), getFilename());
4823. }
4824. }
4825. }
4826. match(COLON);
4827. constant_expression();
4828. }
4829. }
4830. catch (RecognitionException pe) {
4831. synPredMatched185 = false;
4832. }
4833. rewind(_m185);
4834. inputState.guessing--;
4835. }
4836. if ( synPredMatched185 ) {
4837. {
4838. switch ( LA(1)) {
4839. case ID:
4840. {
4841. match(ID);
4842. break;
4843. }
4844. case COLON:
4845. {
4846. break;
4847. }
4848. default:
4849. {
4850. throw new NoViableAltException(LT(1), getFilename());
4851. }
4852. }
4853. }
4854. match(COLON);
4855. constant_expression();
4856. }
4857. else if ((_tokenSet_45.member(LA(1))) && (_tokenSet_46.member(LA(2)))) {
4858. declarator();
4859. }
4860. else {
4861. throw new NoViableAltException(LT(1), getFilename());
4862. }
4863.
4864. }
4865. if ( inputState.guessing==0 ) {
4866. m.endMemberDeclarator();
4867. }
4868. }
4869.
4870. public final void template_parameter_list() throws RecognitionException, TokenStreamException {
4871.
4872.
4873. template_parameter();
4874. {
4875. _loop293:
4876. do {
4877. if ((LA(1)==COMMA)) {
4878. match(COMMA);
4879. template_parameter();
4880. }
4881. else {
4882. break _loop293;
4883. }
4884.
4885. } while (true);
4886. }
4887. }
4888.
4889. public final void parameter_list() throws RecognitionException, TokenStreamException {
4890.
4891.
4892. parameter_declaration_list();
4893. {
4894. switch ( LA(1)) {
4895. case ELLIPSIS:
4896. {
4897. match(ELLIPSIS);
4898. break;
4899. }
4900. case RPAREN:
4901. {
4902. break;
4903. }
4904. default:
4905. {
4906. throw new NoViableAltException(LT(1), getFilename());
4907. }
4908. }
4909. }
4910. }
4911.
4912. public final void exception_specification() throws RecognitionException, TokenStreamException {
4913.
4914. String so="";
4915.
4916. match(LITERAL_throw);
4917. match(LPAREN);
4918. {
4919. switch ( LA(1)) {
4920. case ID:
4921. case RPAREN:
4922. case SCOPE:
4923. {
4924. {
4925. switch ( LA(1)) {
4926. case ID:
4927. case SCOPE:
4928. {
4929. so=scope_override();
4930. match(ID);
4931. {
4932. _loop289:
4933. do {
4934. if ((LA(1)==COMMA)) {
4935. match(COMMA);
4936. so=scope_override();
4937. match(ID);
4938. }
4939. else {
4940. break _loop289;
4941. }
4942.
4943. } while (true);
4944. }
4945. break;
4946. }
4947. case RPAREN:
4948. {
4949. break;
4950. }
4951. default:
4952. {
4953. throw new NoViableAltException(LT(1), getFilename());
4954. }
4955. }
4956. }
4957. break;
4958. }
4959. case ELLIPSIS:
4960. {
4961. match(ELLIPSIS);
4962. break;
4963. }
4964. default:
4965. {
4966. throw new NoViableAltException(LT(1), getFilename());
4967. }
4968. }
4969. }
4970. match(RPAREN);
4971. }
4972.
4973. public final void cv_qualifier_seq() throws RecognitionException, TokenStreamException {
4974.
4975.
4976. {
4977. _loop196:
4978. do {
4979. if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL_volatile))) {
4980. type_qualifier();
4981. }
4982. else {
4983. break _loop196;
4984. }
4985.
4986. } while (true);
4987. }
4988. }
4989.
4990. public final void ptr_operator() throws RecognitionException, TokenStreamException {
4991.
4992.
4993. if ( inputState.guessing==0 ) {
4994. m.beginPtrOperator();
4995. }
4996. {
4997. switch ( LA(1)) {
4998. case AMPERSAND:
4999. {
5000. match(AMPERSAND);
5001. if ( inputState.guessing==0 ) {
5002. m.ptrOperator("&");
5003. }
5004. break;
5005. }
5006. case LITERAL__cdecl:
5007. case LITERAL___cdecl:
5008. {
5009. {
5010. switch ( LA(1)) {
5011. case LITERAL__cdecl:
5012. {
5013. match(LITERAL__cdecl);
5014. break;
5015. }
5016. case LITERAL___cdecl:
5017. {
5018. match(LITERAL___cdecl);
5019. break;
5020. }
5021. default:
5022. {
5023. throw new NoViableAltException(LT(1), getFilename());
5024. }
5025. }
5026. }
5027. break;
5028. }
5029. case LITERAL__near:
5030. case LITERAL___near:
5031. {
5032. {
5033. switch ( LA(1)) {
5034. case LITERAL__near:
5035. {
5036. match(LITERAL__near);
5037. break;
5038. }
5039. case LITERAL___near:
5040. {
5041. match(LITERAL___near);
5042. break;
5043. }
5044. default:
5045. {
5046. throw new NoViableAltException(LT(1), getFilename());
5047. }
5048. }
5049. }
5050. break;
5051. }
5052. case LITERAL__far:
5053. case LITERAL___far:
5054. {
5055. {
5056. switch ( LA(1)) {
5057. case LITERAL__far:
5058. {
5059. match(LITERAL__far);
5060. break;
5061. }
5062. case LITERAL___far:
5063. {
5064. match(LITERAL___far);
5065. break;
5066. }
5067. default:
5068. {
5069. throw new NoViableAltException(LT(1), getFilename());
5070. }
5071. }
5072. }
5073. break;
5074. }
5075. case LITERAL___interrupt:
5076. {
5077. match(LITERAL___interrupt);
5078. break;
5079. }
5080. case LITERAL_pascal:
5081. case LITERAL__pascal:
5082. case LITERAL___pascal:
5083. {
5084. {
5085. switch ( LA(1)) {
5086. case LITERAL_pascal:
5087. {
5088. match(LITERAL_pascal);
5089. break;
5090. }
5091. case LITERAL__pascal:
5092. {
5093. match(LITERAL__pascal);
5094. break;
5095. }
5096. case LITERAL___pascal:
5097. {
5098. match(LITERAL___pascal);
5099. break;
5100. }
5101. default:
5102. {
5103. throw new NoViableAltException(LT(1), getFilename());
5104. }
5105. }
5106. }
5107. break;
5108. }
5109. case LITERAL__stdcall:
5110. case LITERAL___stdcall:
5111. {
5112. {
5113. switch ( LA(1)) {
5114. case LITERAL__stdcall:
5115. {
5116. match(LITERAL__stdcall);
5117. break;
5118. }
5119. case LITERAL___stdcall:
5120. {
5121. match(LITERAL___stdcall);
5122. break;
5123. }
5124. default:
5125. {
5126. throw new NoViableAltException(LT(1), getFilename());
5127. }
5128. }
5129. }
5130. break;
5131. }
5132. case ID:
5133. case STAR:
5134. case SCOPE:
5135. {
5136. ptr_to_member();
5137. break;
5138. }
5139. default:
5140. {
5141. throw new NoViableAltException(LT(1), getFilename());
5142. }
5143. }
5144. }
5145. if ( inputState.guessing==0 ) {
5146. m.endPtrOperator();
5147. }
5148. }
5149.
5150. public final void declarator_suffixes() throws RecognitionException, TokenStreamException {
5151.
5152. java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone(); auxBitSet.or(CPPvariabl...5153.
5154. {
5155. if ((LA(1)==LSQUARE)) {
5156. {
5157. int _cnt220=0;
5158. _loop220:
5159. do {
5160. if ((LA(1)==LSQUARE) && (_tokenSet_32.member(LA(2)))) {
5161. match(LSQUARE);
5162. {
5163. switch ( LA(1)) {
5164. case ID:
5165. case StringLiteral:
5166. case LITERAL__declspec:
5167. case LITERAL___declspec:
5168. case LPAREN:
5169. case LITERAL_const_cast:
5170. case LITERAL_char:
5171. case LITERAL_wchar_t:
5172. case LITERAL_bool:
5173. case LITERAL_short:
5174. case LITERAL_int:
5175. case 44:
5176. case 45:
5177. case 46:
5178. case LITERAL_long:
5179. case LITERAL_signed:
5180. case LITERAL_unsigned:
5181. case LITERAL_float:
5182. case LITERAL_double:
5183. case LITERAL_void:
5184. case OPERATOR:
5185. case LITERAL_this:
5186. case LITERAL_true:
5187. case LITERAL_false:
5188. case OCTALINT:
5189. case STAR:
5190. case AMPERSAND:
5191. case TILDE:
5192. case PLUS:
5193. case MINUS:
5194. case PLUSPLUS:
5195. case MINUSMINUS:
5196. case LITERAL_sizeof:
5197. case SCOPE:
5198. case LITERAL_dynamic_cast:
5199. case LITERAL_static_cast:
5200. case LITERAL_reinterpret_cast:
5201. case NOT:
5202. case LITERAL_new:
5203. case LITERAL_delete:
5204. case DECIMALINT:
5205. case HEXADECIMALINT:
5206. case CharLiteral:
5207. case FLOATONE:
5208. case FLOATTWO:
5209. {
5210. constant_expression();
5211. break;
5212. }
5213. case RSQUARE:
5214. {
5215. break;
5216. }
5217. default:
5218. {
5219. throw new NoViableAltException(LT(1), getFilename());
5220. }
5221. }
5222. }
5223. match(RSQUARE);
5224. }
5225. else {
5226. if ( _cnt220>=1 ) { break _loop220; } else {throw new NoViableAltException(LT(1), getFilename()...5227. }
5228.
5229. _cnt220++;
5230. } while (true);
5231. }
5232. }
5233. else if (((LA(1)==LPAREN))&&((!((LA(1)==LPAREN)&&(LA(2)==ID))||(qualifiedItemIsOneOf(auxBitSet,1))...5234. match(LPAREN);
5235. {
5236. switch ( LA(1)) {
5237. case LITERAL_typedef:
5238. case LITERAL_enum:
5239. case ID:
5240. case LITERAL_inline:
5241. case LITERAL_extern:
5242. case LITERAL__inline:
5243. case LITERAL___inline:
5244. case LITERAL_virtual:
5245. case LITERAL_explicit:
5246. case LITERAL_friend:
5247. case LITERAL__stdcall:
5248. case LITERAL___stdcall:
5249. case LITERAL__declspec:
5250. case LITERAL___declspec:
5251. case LPAREN:
5252. case LITERAL_typename:
5253. case LITERAL_auto:
5254. case LITERAL_register:
5255. case LITERAL_static:
5256. case LITERAL_mutable:
5257. case LITERAL_const:
5258. case LITERAL_const_cast:
5259. case LITERAL_volatile:
5260. case LITERAL_char:
5261. case LITERAL_wchar_t:
5262. case LITERAL_bool:
5263. case LITERAL_short:
5264. case LITERAL_int:
5265. case 44:
5266. case 45:
5267. case 46:
5268. case LITERAL_long:
5269. case LITERAL_signed:
5270. case LITERAL_unsigned:
5271. case LITERAL_float:
5272. case LITERAL_double:
5273. case LITERAL_void:
5274. case LITERAL_class:
5275. case LITERAL_struct:
5276. case LITERAL_union:
5277. case OPERATOR:
5278. case LITERAL_this:
5279. case LITERAL_true:
5280. case LITERAL_false:
5281. case STAR:
5282. case AMPERSAND:
5283. case TILDE:
5284. case ELLIPSIS:
5285. case SCOPE:
5286. case LITERAL__cdecl:
5287. case LITERAL___cdecl:
5288. case LITERAL__near:
5289. case LITERAL___near:
5290. case LITERAL__far:
5291. case LITERAL___far:
5292. case LITERAL___interrupt:
5293. case LITERAL_pascal:
5294. case LITERAL__pascal:
5295. case LITERAL___pascal:
5296. {
5297. parameter_list();
5298. break;
5299. }
5300. case RPAREN:
5301. {
5302. break;
5303. }
5304. default:
5305. {
5306. throw new NoViableAltException(LT(1), getFilename());
5307. }
5308. }
5309. }
5310. match(RPAREN);
5311. {
5312. _loop223:
5313. do {
5314. if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL_volatile))) {
5315. type_qualifier();
5316. }
5317. else {
5318. break _loop223;
5319. }
5320.
5321. } while (true);
5322. }
5323. {
5324. switch ( LA(1)) {
5325. case LITERAL_throw:
5326. {
5327. exception_specification();
5328. break;
5329. }
5330. case LESSTHAN:
5331. case GREATERTHAN:
5332. case ID:
5333. case SEMICOLON:
5334. case RCURLY:
5335. case ASSIGNEQUAL:
5336. case COLON:
5337. case COMMA:
5338. case LITERAL__stdcall:
5339. case LITERAL___stdcall:
5340. case LPAREN:
5341. case RPAREN:
5342. case OPERATOR:
5343. case LITERAL_this:
5344. case LITERAL_true:
5345. case LITERAL_false:
5346. case STAR:
5347. case AMPERSAND:
5348. case LSQUARE:
5349. case RSQUARE:
5350. case TILDE:
5351. case ELLIPSIS:
5352. case TIMESEQUAL:
5353. case DIVIDEEQUAL:
5354. case MINUSEQUAL:
5355. case PLUSEQUAL:
5356. case MODEQUAL:
5357. case SHIFTLEFTEQUAL:
5358. case SHIFTRIGHTEQUAL:
5359. case BITWISEANDEQUAL:
5360. case BITWISEXOREQUAL:
5361. case BITWISEOREQUAL:
5362. case QUESTIONMARK:
5363. case OR:
5364. case AND:
5365. case BITWISEOR:
5366. case BITWISEXOR:
5367. case NOTEQUAL:
5368. case EQUAL:
5369. case LESSTHANOREQUALTO:
5370. case GREATERTHANOREQUALTO:
5371. case SHIFTLEFT:
5372. case SHIFTRIGHT:
5373. case PLUS:
5374. case MINUS:
5375. case DIVIDE:
5376. case MOD:
5377. case DOTMBR:
5378. case POINTERTOMBR:
5379. case SCOPE:
5380. case LITERAL__cdecl:
5381. case LITERAL___cdecl:
5382. case LITERAL__near:
5383. case LITERAL___near:
5384. case LITERAL__far:
5385. case LITERAL___far:
5386. case LITERAL___interrupt:
5387. case LITERAL_pascal:
5388. case LITERAL__pascal:
5389. case LITERAL___pascal:
5390. {
5391. break;
5392. }
5393. default:
5394. {
5395. throw new NoViableAltException(LT(1), getFilename());
5396. }
5397. }
5398. }
5399. }
5400. else {
5401. throw new NoViableAltException(LT(1), getFilename());
5402. }
5403.
5404. }
5405. }
5406.
5407. public final void function_direct_declarator() throws RecognitionException, TokenStreamException {
...5408.
5409. String q="";
5410.
5411. {
5412. switch ( LA(1)) {
5413. case LPAREN:
5414. {
5415. match(LPAREN);
5416. q=qualified_id();
5417. if ( inputState.guessing==0 ) {
5418.
5419. declaratorID(q,CPPvariables.QI_FUN);
5420.
5421. }
5422. match(RPAREN);
5423. break;
5424. }
5425. case ID:
5426. case OPERATOR:
5427. case LITERAL_this:
5428. case LITERAL_true:
5429. case LITERAL_false:
5430. case SCOPE:
5431. {
5432. q=qualified_id();
5433. if ( inputState.guessing==0 ) {
5434.
5435. declaratorID(q,CPPvariables.QI_FUN);
5436.
5437. }
5438. break;
5439. }
5440. default:
5441. {
5442. throw new NoViableAltException(LT(1), getFilename());
5443. }
5444. }
5445. }
5446. if ( inputState.guessing==0 ) {
5447. m.functionDirectDeclarator(q);
5448. }
5449. match(LPAREN);
5450. {
5451. switch ( LA(1)) {
5452. case LITERAL_typedef:
5453. case LITERAL_enum:
5454. case ID:
5455. case LITERAL_inline:
5456. case LITERAL_extern:
5457. case LITERAL__inline:
5458. case LITERAL___inline:
5459. case LITERAL_virtual:
5460. case LITERAL_explicit:
5461. case LITERAL_friend:
5462. case LITERAL__stdcall:
5463. case LITERAL___stdcall:
5464. case LITERAL__declspec:
5465. case LITERAL___declspec:
5466. case LPAREN:
5467. case LITERAL_typename:
5468. case LITERAL_auto:
5469. case LITERAL_register:
5470. case LITERAL_static:
5471. case LITERAL_mutable:
5472. case LITERAL_const:
5473. case LITERAL_const_cast:
5474. case LITERAL_volatile:
5475. case LITERAL_char:
5476. case LITERAL_wchar_t:
5477. case LITERAL_bool:
5478. case LITERAL_short:
5479. case LITERAL_int:
5480. case 44:
5481. case 45:
5482. case 46:
5483. case LITERAL_long:
5484. case LITERAL_signed:
5485. case LITERAL_unsigned:
5486. case LITERAL_float:
5487. case LITERAL_double:
5488. case LITERAL_void:
5489. case LITERAL_class:
5490. case LITERAL_struct:
5491. case LITERAL_union:
5492. case OPERATOR:
5493. case LITERAL_this:
5494. case LITERAL_true:
5495. case LITERAL_false:
5496. case STAR:
5497. case AMPERSAND:
5498. case TILDE:
5499. case ELLIPSIS:
5500. case SCOPE:
5501. case LITERAL__cdecl:
5502. case LITERAL___cdecl:
5503. case LITERAL__near:
5504. case LITERAL___near:
5505. case LITERAL__far:
5506. case LITERAL___far:
5507. case LITERAL___interrupt:
5508. case LITERAL_pascal:
5509. case LITERAL__pascal:
5510. case LITERAL___pascal:
5511. {
5512. parameter_list();
5513. break;
5514. }
5515. case RPAREN:
5516. {
5517. break;
5518. }
5519. default:
5520. {
5521. throw new NoViableAltException(LT(1), getFilename());
5522. }
5523. }
5524. }
5525. match(RPAREN);
5526. {
5527. _loop232:
5528. do {
5529. if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL_volatile)) && (_tokenSet_47.member(LA(2)))) {
5530. type_qualifier();
5531. }
5532. else {
5533. break _loop232;
5534. }
5535.
5536. } while (true);
5537. }
5538. {
5539. switch ( LA(1)) {
5540. case ASSIGNEQUAL:
5541. {
5542. match(ASSIGNEQUAL);
5543. match(OCTALINT);
5544. break;
5545. }
5546. case LITERAL_typedef:
5547. case LITERAL_enum:
5548. case ID:
5549. case LCURLY:
5550. case SEMICOLON:
5551. case LITERAL_inline:
5552. case LITERAL_extern:
5553. case LITERAL__inline:
5554. case LITERAL___inline:
5555. case LITERAL_virtual:
5556. case LITERAL_explicit:
5557. case LITERAL_friend:
5558. case LITERAL__stdcall:
5559. case LITERAL___stdcall:
5560. case LITERAL__declspec:
5561. case LITERAL___declspec:
5562. case LITERAL_typename:
5563. case LITERAL_auto:
5564. case LITERAL_register:
5565. case LITERAL_static:
5566. case LITERAL_mutable:
5567. case LITERAL_const:
5568. case LITERAL_const_cast:
5569. case LITERAL_volatile:
5570. case LITERAL_char:
5571. case LITERAL_wchar_t:
5572. case LITERAL_bool:
5573. case LITERAL_short:
5574. case LITERAL_int:
5575. case 44:
5576. case 45:
5577. case 46:
5578. case LITERAL_long:
5579. case LITERAL_signed:
5580. case LITERAL_unsigned:
5581. case LITERAL_float:
5582. case LITERAL_double:
5583. case LITERAL_void:
5584. case LITERAL_class:
5585. case LITERAL_struct:
5586. case LITERAL_union:
5587. case LITERAL_throw:
5588. case LITERAL_using:
5589. case SCOPE:
5590. {
5591. break;
5592. }
5593. default:
5594. {
5595. throw new NoViableAltException(LT(1), getFilename());
5596. }
5597. }
5598. }
5599. {
5600. switch ( LA(1)) {
5601. case LITERAL_throw:
5602. {
5603. exception_specification();
5604. break;
5605. }
5606. case LITERAL_typedef:
5607. case LITERAL_enum:
5608. case ID:
5609. case LCURLY:
5610. case SEMICOLON:
5611. case LITERAL_inline:
5612. case LITERAL_extern:
5613. case LITERAL__inline:
5614. case LITERAL___inline:
5615. case LITERAL_virtual:
5616. case LITERAL_explicit:
5617. case LITERAL_friend:
5618. case LITERAL__stdcall:
5619. case LITERAL___stdcall:
5620. case LITERAL__declspec:
5621. case LITERAL___declspec:
5622. case LITERAL_typename:
5623. case LITERAL_auto:
5624. case LITERAL_register:
5625. case LITERAL_static:
5626. case LITERAL_mutable:
5627. case LITERAL_const:
5628. case LITERAL_const_cast:
5629. case LITERAL_volatile:
5630. case LITERAL_char:
5631. case LITERAL_wchar_t:
5632. case LITERAL_bool:
5633. case LITERAL_short:
5634. case LITERAL_int:
5635. case 44:
5636. case 45:
5637. case 46:
5638. case LITERAL_long:
5639. case LITERAL_signed:
5640. case LITERAL_unsigned:
5641. case LITERAL_float:
5642. case LITERAL_double:
5643. case LITERAL_void:
5644. case LITERAL_class:
5645. case LITERAL_struct:
5646. case LITERAL_union:
5647. case LITERAL_using:
5648. case SCOPE:
5649. {
5650. break;
5651. }
5652. default:
5653. {
5654. throw new NoViableAltException(LT(1), getFilename());
5655. }
5656. }
5657. }
5658. }
5659.
5660. public final void ctor_head() throws RecognitionException, TokenStreamException {
5661.
5662.
5663. ctor_decl_spec();
5664. ctor_declarator();
5665. }
5666.
5667. public final void ctor_body() throws RecognitionException, TokenStreamException {
5668.
5669.
5670. {
5671. switch ( LA(1)) {
5672. case COLON:
5673. {
5674. ctor_initializer();
5675. break;
5676. }
5677. case LCURLY:
5678. {
5679. break;
5680. }
5681. default:
5682. {
5683. throw new NoViableAltException(LT(1), getFilename());
5684. }
5685. }
5686. }
5687. compound_statement();
5688. }
5689.
5690. public final String qualified_ctor_id() throws RecognitionException, TokenStreamException {
5691. String q="";
5692.
5693. Token id = null;
5694.
5695. String so="";
5696. String qitem="";
5697.
5698.
5699. so=scope_override();
5700. if ( inputState.guessing==0 ) {
5701. qitem=so;
5702. }
5703. id = LT(1);
5704. match(ID);
5705. if ( inputState.guessing==0 ) {
5706. qitem=qitem+id.getText();
5707. q = qitem;
5708. }
5709. return q;
5710. }
5711.
5712. public final void ctor_initializer() throws RecognitionException, TokenStreamException {
5713.
5714.
5715. match(COLON);
5716. superclass_init();
5717. {
5718. _loop249:
5719. do {
5720. if ((LA(1)==COMMA)) {
5721. match(COMMA);
5722. superclass_init();
5723. }
5724. else {
5725. break _loop249;
5726. }
5727.
5728. } while (true);
5729. }
5730. }
5731.
5732. public final void superclass_init() throws RecognitionException, TokenStreamException {
5733.
5734. String q="";
5735.
5736. q=qualified_id();
5737. match(LPAREN);
5738. {
5739. switch ( LA(1)) {
5740. case ID:
5741. case StringLiteral:
5742. case LITERAL__declspec:
5743. case LITERAL___declspec:
5744. case LPAREN:
5745. case LITERAL_const_cast:
5746. case LITERAL_char:
5747. case LITERAL_wchar_t:
5748. case LITERAL_bool:
5749. case LITERAL_short:
5750. case LITERAL_int:
5751. case 44:
5752. case 45:
5753. case 46:
5754. case LITERAL_long:
5755. case LITERAL_signed:
5756. case LITERAL_unsigned:
5757. case LITERAL_float:
5758. case LITERAL_double:
5759. case LITERAL_void:
5760. case OPERATOR:
5761. case LITERAL_this:
5762. case LITERAL_true:
5763. case LITERAL_false:
5764. case OCTALINT:
5765. case STAR:
5766. case AMPERSAND:
5767. case TILDE:
5768. case PLUS:
5769. case MINUS:
5770. case PLUSPLUS:
5771. case MINUSMINUS:
5772. case LITERAL_sizeof:
5773. case SCOPE:
5774. case LITERAL_dynamic_cast:
5775. case LITERAL_static_cast:
5776. case LITERAL_reinterpret_cast:
5777. case NOT:
5778. case LITERAL_new:
5779. case LITERAL_delete:
5780. case DECIMALINT:
5781. case HEXADECIMALINT:
5782. case CharLiteral:
5783. case FLOATONE:
5784. case FLOATTWO:
5785. {
5786. expression_list();
5787. break;
5788. }
5789. case RPAREN:
5790. {
5791. break;
5792. }
5793. default:
5794. {
5795. throw new NoViableAltException(LT(1), getFilename());
5796. }
5797. }
5798. }
5799. match(RPAREN);
5800. }
5801.
5802. public final void dtor_decl_spec() throws RecognitionException, TokenStreamException {
5803.
5804. List declSpecs = new ArrayList();
5805.
5806. {
5807. _loop256:
5808. do {
5809. switch ( LA(1)) {
5810. case LITERAL_inline:
5811. case LITERAL__inline:
5812. case LITERAL___inline:
5813. {
5814. {
5815. switch ( LA(1)) {
5816. case LITERAL_inline:
5817. {
5818. match(LITERAL_inline);
5819. break;
5820. }
5821. case LITERAL__inline:
5822. {
5823. match(LITERAL__inline);
5824. break;
5825. }
5826. case LITERAL___inline:
5827. {
5828. match(LITERAL___inline);
5829. break;
5830. }
5831. default:
5832. {
5833. throw new NoViableAltException(LT(1), getFilename());
5834. }
5835. }
5836. }
5837. if ( inputState.guessing==0 ) {
5838. declSpecs.add("inline");
5839. }
5840. break;
5841. }
5842. case LITERAL_virtual:
5843. {
5844. match(LITERAL_virtual);
5845. if ( inputState.guessing==0 ) {
5846. declSpecs.add("virtual");
5847. }
5848. break;
5849. }
5850. default:
5851. {
5852. break _loop256;
5853. }
5854. }
5855. } while (true);
5856. }
5857. if ( inputState.guessing==0 ) {
5858. m.declarationSpecifiers(declSpecs);
5859. }
5860. }
5861.
5862. public final void dtor_declarator() throws RecognitionException, TokenStreamException {
5863.
5864. Token id = null;
5865. String s="";
5866.
5867. s=scope_override();
5868. match(TILDE);
5869. id = LT(1);
5870. match(ID);
5871. if ( inputState.guessing==0 ) {
5872. m.dtorDeclarator(s+"~"+id.getText());
5873. }
5874. match(LPAREN);
5875. match(RPAREN);
5876. {
5877. switch ( LA(1)) {
5878. case LITERAL_throw:
5879. {
5880. exception_specification();
5881. break;
5882. }
5883. case LCURLY:
5884. case SEMICOLON:
5885. {
5886. break;
5887. }
5888. default:
5889. {
5890. throw new NoViableAltException(LT(1), getFilename());
5891. }
5892. }
5893. }
5894. }
5895.
5896. public final void parameter_declaration_list() throws RecognitionException, TokenStreamException {
...5897.
5898.
5899. {
5900. parameter_declaration();
5901. {
5902. _loop265:
5903. do {
5904. if ((LA(1)==COMMA)) {
5905. match(COMMA);
5906. parameter_declaration();
5907. }
5908. else {
5909. break _loop265;
5910. }
5911.
5912. } while (true);
5913. }
5914. }
5915. }
5916.
5917. public final void parameter_declaration() throws RecognitionException, TokenStreamException {
5918.
5919. java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone(); auxBitSet.or(CPPvariabl...5920.
5921. if ( inputState.guessing==0 ) {
5922. m.beginParameterDeclaration();
5923. }
5924. {
5925. if (((_tokenSet_11.member(LA(1))) && (_tokenSet_48.member(LA(2))))&&(!((LA(1)==SCOPE) && (LA(2)==S...5926. declaration_specifiers();
5927. {
5928. boolean synPredMatched270 = false;
5929. if (((_tokenSet_45.member(LA(1))) && (_tokenSet_49.member(LA(2))))) {
5930. int _m270 = mark();
5931. synPredMatched270 = true;
5932. inputState.guessing++;
5933. try {
5934. {
5935. declarator();
5936. }
5937. }
5938. catch (RecognitionException pe) {
5939. synPredMatched270 = false;
5940. }
5941. rewind(_m270);
5942. inputState.guessing--;
5943. }
5944. if ( synPredMatched270 ) {
5945. declarator();
5946. }
5947. else if ((_tokenSet_50.member(LA(1))) && (_tokenSet_51.member(LA(2)))) {
5948. abstract_declarator();
5949. }
5950. else {
5951. throw new NoViableAltException(LT(1), getFilename());
5952. }
5953.
5954. }
5955. }
5956. else {
5957. boolean synPredMatched272 = false;
5958. if (((_tokenSet_45.member(LA(1))) && (_tokenSet_49.member(LA(2))))) {
5959. int _m272 = mark();
5960. synPredMatched272 = true;
5961. inputState.guessing++;
5962. try {
5963. {
5964. declarator();
5965. }
5966. }
5967. catch (RecognitionException pe) {
5968. synPredMatched272 = false;
5969. }
5970. rewind(_m272);
5971. inputState.guessing--;
5972. }
5973. if ( synPredMatched272 ) {
5974. declarator();
5975. }
5976. else if ((LA(1)==ELLIPSIS)) {
5977. match(ELLIPSIS);
5978. }
5979. else {
5980. throw new NoViableAltException(LT(1), getFilename());
5981. }
5982. }
5983. }
5984. {
5985. switch ( LA(1)) {
5986. case ASSIGNEQUAL:
5987. {
5988. match(ASSIGNEQUAL);
5989. remainder_expression();
5990. break;
5991. }
5992. case GREATERTHAN:
5993. case COMMA:
5994. case RPAREN:
5995. case ELLIPSIS:
5996. {
5997. break;
5998. }
5999. default:
6000. {
6001. throw new NoViableAltException(LT(1), getFilename());
6002. }
6003. }
6004. }
6005. if ( inputState.guessing==0 ) {
6006. m.endParameterDeclaration();
6007. }
6008. }
6009.
6010. public final void abstract_declarator() throws RecognitionException, TokenStreamException {
6011.
6012.
6013. switch ( LA(1)) {
6014. case ID:
6015. case LITERAL__stdcall:
6016. case LITERAL___stdcall:
6017. case STAR:
6018. case AMPERSAND:
6019. case SCOPE:
6020. case LITERAL__cdecl:
6021. case LITERAL___cdecl:
6022. case LITERAL__near:
6023. case LITERAL___near:
6024. case LITERAL__far:
6025. case LITERAL___far:
6026. case LITERAL___interrupt:
6027. case LITERAL_pascal:
6028. case LITERAL__pascal:
6029. case LITERAL___pascal:
6030. {
6031. ptr_operator();
6032. abstract_declarator();
6033. break;
6034. }
6035. case LPAREN:
6036. {
6037. match(LPAREN);
6038. abstract_declarator();
6039. match(RPAREN);
6040. {
6041. int _cnt277=0;
6042. _loop277:
6043. do {
6044. if ((LA(1)==LPAREN||LA(1)==LSQUARE)) {
6045. abstract_declarator_suffix();
6046. }
6047. else {
6048. if ( _cnt277>=1 ) { break _loop277; } else {throw new NoViableAltException(LT(1), getFilename()...6049. }
6050.
6051. _cnt277++;
6052. } while (true);
6053. }
6054. break;
6055. }
6056. case LSQUARE:
6057. {
6058. {
6059. int _cnt280=0;
6060. _loop280:
6061. do {
6062. if ((LA(1)==LSQUARE)) {
6063. match(LSQUARE);
6064. {
6065. switch ( LA(1)) {
6066. case ID:
6067. case StringLiteral:
6068. case LITERAL__declspec:
6069. case LITERAL___declspec:
6070. case LPAREN:
6071. case LITERAL_const_cast:
6072. case LITERAL_char:
6073. case LITERAL_wchar_t:
6074. case LITERAL_bool:
6075. case LITERAL_short:
6076. case LITERAL_int:
6077. case 44:
6078. case 45:
6079. case 46:
6080. case LITERAL_long:
6081. case LITERAL_signed:
6082. case LITERAL_unsigned:
6083. case LITERAL_float:
6084. case LITERAL_double:
6085. case LITERAL_void:
6086. case OPERATOR:
6087. case LITERAL_this:
6088. case LITERAL_true:
6089. case LITERAL_false:
6090. case OCTALINT:
6091. case STAR:
6092. case AMPERSAND:
6093. case TILDE:
6094. case PLUS:
6095. case MINUS:
6096. case PLUSPLUS:
6097. case MINUSMINUS:
6098. case LITERAL_sizeof:
6099. case SCOPE:
6100. case LITERAL_dynamic_cast:
6101. case LITERAL_static_cast:
6102. case LITERAL_reinterpret_cast:
6103. case NOT:
6104. case LITERAL_new:
6105. case LITERAL_delete:
6106. case DECIMALINT:
6107. case HEXADECIMALINT:
6108. case CharLiteral:
6109. case FLOATONE:
6110. case FLOATTWO:
6111. {
6112. constant_expression();
6113. break;
6114. }
6115. case RSQUARE:
6116. {
6117. break;
6118. }
6119. default:
6120. {
6121. throw new NoViableAltException(LT(1), getFilename());
6122. }
6123. }
6124. }
6125. match(RSQUARE);
6126. }
6127. else {
6128. if ( _cnt280>=1 ) { break _loop280; } else {throw new NoViableAltException(LT(1), getFilename()...6129. }
6130.
6131. _cnt280++;
6132. } while (true);
6133. }
6134. break;
6135. }
6136. case GREATERTHAN:
6137. case ASSIGNEQUAL:
6138. case COMMA:
6139. case RPAREN:
6140. case ELLIPSIS:
6141. {
6142. break;
6143. }
6144. default:
6145. {
6146. throw new NoViableAltException(LT(1), getFilename());
6147. }
6148. }
6149. }
6150.
6151. public final void type_name() throws RecognitionException, TokenStreamException {
6152.
6153.
6154. declaration_specifiers();
6155. abstract_declarator();
6156. }
6157.
6158. public final void abstract_declarator_suffix() throws RecognitionException, TokenStreamException {
...6159.
6160.
6161. switch ( LA(1)) {
6162. case LSQUARE:
6163. {
6164. match(LSQUARE);
6165. {
6166. switch ( LA(1)) {
6167. case ID:
6168. case StringLiteral:
6169. case LITERAL__declspec:
6170. case LITERAL___declspec:
6171. case LPAREN:
6172. case LITERAL_const_cast:
6173. case LITERAL_char:
6174. case LITERAL_wchar_t:
6175. case LITERAL_bool:
6176. case LITERAL_short:
6177. case LITERAL_int:
6178. case 44:
6179. case 45:
6180. case 46:
6181. case LITERAL_long:
6182. case LITERAL_signed:
6183. case LITERAL_unsigned:
6184. case LITERAL_float:
6185. case LITERAL_double:
6186. case LITERAL_void:
6187. case OPERATOR:
6188. case LITERAL_this:
6189. case LITERAL_true:
6190. case LITERAL_false:
6191. case OCTALINT:
6192. case STAR:
6193. case AMPERSAND:
6194. case TILDE:
6195. case PLUS:
6196. case MINUS:
6197. case PLUSPLUS:
6198. case MINUSMINUS:
6199. case LITERAL_sizeof:
6200. case SCOPE:
6201. case LITERAL_dynamic_cast:
6202. case LITERAL_static_cast:
6203. case LITERAL_reinterpret_cast:
6204. case NOT:
6205. case LITERAL_new:
6206. case LITERAL_delete:
6207. case DECIMALINT:
6208. case HEXADECIMALINT:
6209. case CharLiteral:
6210. case FLOATONE:
6211. case FLOATTWO:
6212. {
6213. constant_expression();
6214. break;
6215. }
6216. case RSQUARE:
6217. {
6218. break;
6219. }
6220. default:
6221. {
6222. throw new NoViableAltException(LT(1), getFilename());
6223. }
6224. }
6225. }
6226. match(RSQUARE);
6227. break;
6228. }
6229. case LPAREN:
6230. {
6231. match(LPAREN);
6232. {
6233. switch ( LA(1)) {
6234. case LITERAL_typedef:
6235. case LITERAL_enum:
6236. case ID:
6237. case LITERAL_inline:
6238. case LITERAL_extern:
6239. case LITERAL__inline:
6240. case LITERAL___inline:
6241. case LITERAL_virtual:
6242. case LITERAL_explicit:
6243. case LITERAL_friend:
6244. case LITERAL__stdcall:
6245. case LITERAL___stdcall:
6246. case LITERAL__declspec:
6247. case LITERAL___declspec:
6248. case LPAREN:
6249. case LITERAL_typename:
6250. case LITERAL_auto:
6251. case LITERAL_register:
6252. case LITERAL_static:
6253. case LITERAL_mutable:
6254. case LITERAL_const:
6255. case LITERAL_const_cast:
6256. case LITERAL_volatile:
6257. case LITERAL_char:
6258. case LITERAL_wchar_t:
6259. case LITERAL_bool:
6260. case LITERAL_short:
6261. case LITERAL_int:
6262. case 44:
6263. case 45:
6264. case 46:
6265. case LITERAL_long:
6266. case LITERAL_signed:
6267. case LITERAL_unsigned:
6268. case LITERAL_float:
6269. case LITERAL_double:
6270. case LITERAL_void:
6271. case LITERAL_class:
6272. case LITERAL_struct:
6273. case LITERAL_union:
6274. case OPERATOR:
6275. case LITERAL_this:
6276. case LITERAL_true:
6277. case LITERAL_false:
6278. case STAR:
6279. case AMPERSAND:
6280. case TILDE:
6281. case ELLIPSIS:
6282. case SCOPE:
6283. case LITERAL__cdecl:
6284. case LITERAL___cdecl:
6285. case LITERAL__near:
6286. case LITERAL___near:
6287. case LITERAL__far:
6288. case LITERAL___far:
6289. case LITERAL___interrupt:
6290. case LITERAL_pascal:
6291. case LITERAL__pascal:
6292. case LITERAL___pascal:
6293. {
6294. parameter_list();
6295. break;
6296. }
6297. case RPAREN:
6298. {
6299. break;
6300. }
6301. default:
6302. {
6303. throw new NoViableAltException(LT(1), getFilename());
6304. }
6305. }
6306. }
6307. match(RPAREN);
6308. cv_qualifier_seq();
6309. {
6310. switch ( LA(1)) {
6311. case LITERAL_throw:
6312. {
6313. exception_specification();
6314. break;
6315. }
6316. case GREATERTHAN:
6317. case ASSIGNEQUAL:
6318. case COMMA:
6319. case LPAREN:
6320. case RPAREN:
6321. case LSQUARE:
6322. case ELLIPSIS:
6323. {
6324. break;
6325. }
6326. default:
6327. {
6328. throw new NoViableAltException(LT(1), getFilename());
6329. }
6330. }
6331. }
6332. break;
6333. }
6334. default:
6335. {
6336. throw new NoViableAltException(LT(1), getFilename());
6337. }
6338. }
6339. }
6340.
6341. public final void template_parameter() throws RecognitionException, TokenStreamException {
6342.
6343. Token id = null;
6344.
6345. {
6346. if ((LA(1)==LITERAL_typename||LA(1)==LITERAL_class) && (_tokenSet_52.member(LA(2)))) {
6347. {
6348. switch ( LA(1)) {
6349. case LITERAL_class:
6350. {
6351. match(LITERAL_class);
6352. break;
6353. }
6354. case LITERAL_typename:
6355. {
6356. match(LITERAL_typename);
6357. break;
6358. }
6359. default:
6360. {
6361. throw new NoViableAltException(LT(1), getFilename());
6362. }
6363. }
6364. }
6365. {
6366. switch ( LA(1)) {
6367. case ID:
6368. {
6369. id = LT(1);
6370. match(ID);
6371. {
6372. switch ( LA(1)) {
6373. case ASSIGNEQUAL:
6374. {
6375. match(ASSIGNEQUAL);
6376. assigned_type_name();
6377. break;
6378. }
6379. case GREATERTHAN:
6380. case COMMA:
6381. {
6382. break;
6383. }
6384. default:
6385. {
6386. throw new NoViableAltException(LT(1), getFilename());
6387. }
6388. }
6389. }
6390. break;
6391. }
6392. case GREATERTHAN:
6393. case COMMA:
6394. {
6395. break;
6396. }
6397. default:
6398. {
6399. throw new NoViableAltException(LT(1), getFilename());
6400. }
6401. }
6402. }
6403. if ( inputState.guessing==0 ) {
6404. if(!symbols.containsKey(id.getText()))
6405. symbols.put(id.getText(),CPPvariables.OT_TYPE_DEF);
6406.
6407. }
6408. }
6409. else if ((_tokenSet_53.member(LA(1))) && (_tokenSet_10.member(LA(2)))) {
6410. parameter_declaration();
6411. }
6412. else {
6413. throw new NoViableAltException(LT(1), getFilename());
6414. }
6415.
6416. }
6417. }
6418.
6419. public final void assigned_type_name() throws RecognitionException, TokenStreamException {
6420.
6421. String s="";
6422.
6423. {
6424. if ((LA(1)==ID||LA(1)==SCOPE) && (_tokenSet_54.member(LA(2)))) {
6425. s=qualified_type();
6426. abstract_declarator();
6427. }
6428. else if ((_tokenSet_55.member(LA(1))) && (_tokenSet_56.member(LA(2)))) {
6429. simple_type_specifier();
6430. abstract_declarator();
6431. }
6432. else {
6433. throw new NoViableAltException(LT(1), getFilename());
6434. }
6435.
6436. }
6437. }
6438.
6439. public final void template_id() throws RecognitionException, TokenStreamException {
6440.
6441.
6442. match(ID);
6443. match(LESSTHAN);
6444. template_argument_list();
6445. match(GREATERTHAN);
6446. }
6447.
6448. public final void template_argument() throws RecognitionException, TokenStreamException {
6449.
6450. java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone(); auxBitSet.or(CPPvariabl...6451.
6452. if (((_tokenSet_11.member(LA(1))) && (_tokenSet_57.member(LA(2))))&&(( !(LA(1)==SCOPE||LA(1)==ID) ...6453. type_name();
6454. }
6455. else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_58.member(LA(2)))) {
6456. shift_expression();
6457. }
6458. else {
6459. throw new NoViableAltException(LT(1), getFilename());
6460. }
6461.
6462. }
6463.
6464. public final void shift_expression() throws RecognitionException, TokenStreamException {
6465.
6466.
6467. additive_expression();
6468. {
6469. _loop385:
6470. do {
6471. if ((LA(1)==SHIFTLEFT||LA(1)==SHIFTRIGHT)) {
6472. {
6473. switch ( LA(1)) {
6474. case SHIFTLEFT:
6475. {
6476. match(SHIFTLEFT);
6477. break;
6478. }
6479. case SHIFTRIGHT:
6480. {
6481. match(SHIFTRIGHT);
6482. break;
6483. }
6484. default:
6485. {
6486. throw new NoViableAltException(LT(1), getFilename());
6487. }
6488. }
6489. }
6490. additive_expression();
6491. }
6492. else {
6493. break _loop385;
6494. }
6495.
6496. } while (true);
6497. }
6498. }
6499.
6500. public final void statement_list() throws RecognitionException, TokenStreamException {
6501.
6502.
6503. {
6504. int _cnt308=0;
6505. _loop308:
6506. do {
6507. if ((_tokenSet_59.member(LA(1)))) {
6508. statement();
6509. }
6510. else {
6511. if ( _cnt308>=1 ) { break _loop308; } else {throw new NoViableAltException(LT(1), getFilename())...6512. }
6513.
6514. _cnt308++;
6515. } while (true);
6516. }
6517. }
6518.
6519. public final void statement() throws RecognitionException, TokenStreamException {
6520.
6521.
6522. {
6523. switch ( LA(1)) {
6524. case LITERAL_case:
6525. {
6526. case_statement();
6527. break;
6528. }
6529. case LITERAL_default:
6530. {
6531. default_statement();
6532. break;
6533. }
6534. case LCURLY:
6535. {
6536. compound_statement();
6537. break;
6538. }
6539. case LITERAL_if:
6540. case LITERAL_switch:
6541. {
6542. selection_statement();
6543. break;
6544. }
6545. case LITERAL_while:
6546. case LITERAL_do:
6547. case LITERAL_for:
6548. {
6549. iteration_statement();
6550. break;
6551. }
6552. case LITERAL_goto:
6553. case LITERAL_continue:
6554. case LITERAL_break:
6555. case LITERAL_return:
6556. {
6557. jump_statement();
6558. break;
6559. }
6560. case SEMICOLON:
6561. {
6562. match(SEMICOLON);
6563. break;
6564. }
6565. case LITERAL_try:
6566. {
6567. try_block();
6568. break;
6569. }
6570. case LITERAL_throw:
6571. {
6572. throw_statement();
6573. break;
6574. }
6575. case LITERAL__asm:
6576. case LITERAL___asm:
6577. {
6578. asm_block();
6579. break;
6580. }
6581. default:
6582. boolean synPredMatched312 = false;
6583. if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
6584. int _m312 = mark();
6585. synPredMatched312 = true;
6586. inputState.guessing++;
6587. try {
6588. {
6589. declaration();
6590. }
6591. }
6592. catch (RecognitionException pe) {
6593. synPredMatched312 = false;
6594. }
6595. rewind(_m312);
6596. inputState.guessing--;
6597. }
6598. if ( synPredMatched312 ) {
6599. declaration();
6600. }
6601. else if ((LA(1)==ID) && (LA(2)==COLON)) {
6602. labeled_statement();
6603. }
6604. else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_60.member(LA(2)))) {
6605. expression();
6606. match(SEMICOLON);
6607. }
6608. else {
6609. throw new NoViableAltException(LT(1), getFilename());
6610. }
6611. }
6612. }
6613. }
6614.
6615. public final void labeled_statement() throws RecognitionException, TokenStreamException {
6616.
6617.
6618. match(ID);
6619. match(COLON);
6620. statement();
6621. }
6622.
6623. public final void case_statement() throws RecognitionException, TokenStreamException {
6624.
6625.
6626. match(LITERAL_case);
6627. constant_expression();
6628. match(COLON);
6629. statement();
6630. }
6631.
6632. public final void default_statement() throws RecognitionException, TokenStreamException {
6633.
6634.
6635. match(LITERAL_default);
6636. match(COLON);
6637. statement();
6638. }
6639.
6640. public final void expression() throws RecognitionException, TokenStreamException {
6641.
6642.
6643. assignment_expression();
6644. {
6645. _loop347:
6646. do {
6647. if ((LA(1)==COMMA)) {
6648. match(COMMA);
6649. assignment_expression();
6650. }
6651. else {
6652. break _loop347;
6653. }
6654.
6655. } while (true);
6656. }
6657. }
6658.
6659. public final void selection_statement() throws RecognitionException, TokenStreamException {
6660.
6661.
6662. switch ( LA(1)) {
6663. case LITERAL_if:
6664. {
6665. match(LITERAL_if);
6666. match(LPAREN);
6667. expression();
6668. match(RPAREN);
6669. statement();
6670. {
6671. if ((LA(1)==LITERAL_else) && (_tokenSet_59.member(LA(2)))) {
6672. match(LITERAL_else);
6673. statement();
6674. }
6675. else if ((_tokenSet_61.member(LA(1))) && (_tokenSet_62.member(LA(2)))) {
6676. }
6677. else {
6678. throw new NoViableAltException(LT(1), getFilename());
6679. }
6680.
6681. }
6682. break;
6683. }
6684. case LITERAL_switch:
6685. {
6686. match(LITERAL_switch);
6687. match(LPAREN);
6688. expression();
6689. match(RPAREN);
6690. statement();
6691. break;
6692. }
6693. default:
6694. {
6695. throw new NoViableAltException(LT(1), getFilename());
6696. }
6697. }
6698. }
6699.
6700. public final void iteration_statement() throws RecognitionException, TokenStreamException {
6701.
6702.
6703. switch ( LA(1)) {
6704. case LITERAL_while:
6705. {
6706. match(LITERAL_while);
6707. match(LPAREN);
6708. expression();
6709. match(RPAREN);
6710. statement();
6711. break;
6712. }
6713. case LITERAL_do:
6714. {
6715. match(LITERAL_do);
6716. statement();
6717. match(LITERAL_while);
6718. match(LPAREN);
6719. expression();
6720. match(RPAREN);
6721. match(SEMICOLON);
6722. break;
6723. }
6724. case LITERAL_for:
6725. {
6726. match(LITERAL_for);
6727. match(LPAREN);
6728. {
6729. boolean synPredMatched323 = false;
6730. if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
6731. int _m323 = mark();
6732. synPredMatched323 = true;
6733. inputState.guessing++;
6734. try {
6735. {
6736. declaration();
6737. }
6738. }
6739. catch (RecognitionException pe) {
6740. synPredMatched323 = false;
6741. }
6742. rewind(_m323);
6743. inputState.guessing--;
6744. }
6745. if ( synPredMatched323 ) {
6746. declaration();
6747. }
6748. else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_60.member(LA(2)))) {
6749. expression();
6750. match(SEMICOLON);
6751. }
6752. else if ((LA(1)==SEMICOLON)) {
6753. match(SEMICOLON);
6754. }
6755. else {
6756. throw new NoViableAltException(LT(1), getFilename());
6757. }
6758.
6759. }
6760. {
6761. switch ( LA(1)) {
6762. case ID:
6763. case StringLiteral:
6764. case LITERAL__declspec:
6765. case LITERAL___declspec:
6766. case LPAREN:
6767. case LITERAL_const_cast:
6768. case LITERAL_char:
6769. case LITERAL_wchar_t:
6770. case LITERAL_bool:
6771. case LITERAL_short:
6772. case LITERAL_int:
6773. case 44:
6774. case 45:
6775. case 46:
6776. case LITERAL_long:
6777. case LITERAL_signed:
6778. case LITERAL_unsigned:
6779. case LITERAL_float:
6780. case LITERAL_double:
6781. case LITERAL_void:
6782. case OPERATOR:
6783. case LITERAL_this:
6784. case LITERAL_true:
6785. case LITERAL_false:
6786. case OCTALINT:
6787. case STAR:
6788. case AMPERSAND:
6789. case TILDE:
6790. case PLUS:
6791. case MINUS:
6792. case PLUSPLUS:
6793. case MINUSMINUS:
6794. case LITERAL_sizeof:
6795. case SCOPE:
6796. case LITERAL_dynamic_cast:
6797. case LITERAL_static_cast:
6798. case LITERAL_reinterpret_cast:
6799. case NOT:
6800. case LITERAL_new:
6801. case LITERAL_delete:
6802. case DECIMALINT:
6803. case HEXADECIMALINT:
6804. case CharLiteral:
6805. case FLOATONE:
6806. case FLOATTWO:
6807. {
6808. expression();
6809. break;
6810. }
6811. case SEMICOLON:
6812. {
6813. break;
6814. }
6815. default:
6816. {
6817. throw new NoViableAltException(LT(1), getFilename());
6818. }
6819. }
6820. }
6821. match(SEMICOLON);
6822. {
6823. switch ( LA(1)) {
6824. case ID:
6825. case StringLiteral:
6826. case LITERAL__declspec:
6827. case LITERAL___declspec:
6828. case LPAREN:
6829. case LITERAL_const_cast:
6830. case LITERAL_char:
6831. case LITERAL_wchar_t:
6832. case LITERAL_bool:
6833. case LITERAL_short:
6834. case LITERAL_int:
6835. case 44:
6836. case 45:
6837. case 46:
6838. case LITERAL_long:
6839. case LITERAL_signed:
6840. case LITERAL_unsigned:
6841. case LITERAL_float:
6842. case LITERAL_double:
6843. case LITERAL_void:
6844. case OPERATOR:
6845. case LITERAL_this:
6846. case LITERAL_true:
6847. case LITERAL_false:
6848. case OCTALINT:
6849. case STAR:
6850. case AMPERSAND:
6851. case TILDE:
6852. case PLUS:
6853. case MINUS:
6854. case PLUSPLUS:
6855. case MINUSMINUS:
6856. case LITERAL_sizeof:
6857. case SCOPE:
6858. case LITERAL_dynamic_cast:
6859. case LITERAL_static_cast:
6860. case LITERAL_reinterpret_cast:
6861. case NOT:
6862. case LITERAL_new:
6863. case LITERAL_delete:
6864. case DECIMALINT:
6865. case HEXADECIMALINT:
6866. case CharLiteral:
6867. case FLOATONE:
6868. case FLOATTWO:
6869. {
6870. expression();
6871. break;
6872. }
6873. case RPAREN:
6874. {
6875. break;
6876. }
6877. default:
6878. {
6879. throw new NoViableAltException(LT(1), getFilename());
6880. }
6881. }
6882. }
6883. match(RPAREN);
6884. statement();
6885. break;
6886. }
6887. default:
6888. {
6889. throw new NoViableAltException(LT(1), getFilename());
6890. }
6891. }
6892. }
6893.
6894. public final void jump_statement() throws RecognitionException, TokenStreamException {
6895.
6896.
6897. {
6898. switch ( LA(1)) {
6899. case LITERAL_goto:
6900. {
6901. match(LITERAL_goto);
6902. match(ID);
6903. match(SEMICOLON);
6904. break;
6905. }
6906. case LITERAL_continue:
6907. {
6908. match(LITERAL_continue);
6909. match(SEMICOLON);
6910. break;
6911. }
6912. case LITERAL_break:
6913. {
6914. match(LITERAL_break);
6915. match(SEMICOLON);
6916. break;
6917. }
6918. case LITERAL_return:
6919. {
6920. match(LITERAL_return);
6921. {
6922. boolean synPredMatched330 = false;
6923. if (((LA(1)==LPAREN) && (LA(2)==ID))) {
6924. int _m330 = mark();
6925. synPredMatched330 = true;
6926. inputState.guessing++;
6927. try {
6928. {
6929. match(LPAREN);
6930. if (!((qualifiedItemIsOneOf(CPPvariables.QI_TYPE,0) )))
6931. throw new SemanticException("(qualifiedItemIsOneOf(CPPvariables.QI_TYPE,0) )");
6932. match(ID);
6933. match(RPAREN);
6934. }
6935. }
6936. catch (RecognitionException pe) {
6937. synPredMatched330 = false;
6938. }
6939. rewind(_m330);
6940. inputState.guessing--;
6941. }
6942. if ( synPredMatched330 ) {
6943. match(LPAREN);
6944. match(ID);
6945. match(RPAREN);
6946. {
6947. switch ( LA(1)) {
6948. case ID:
6949. case StringLiteral:
6950. case LITERAL__declspec:
6951. case LITERAL___declspec:
6952. case LPAREN:
6953. case LITERAL_const_cast:
6954. case LITERAL_char:
6955. case LITERAL_wchar_t:
6956. case LITERAL_bool:
6957. case LITERAL_short:
6958. case LITERAL_int:
6959. case 44:
6960. case 45:
6961. case 46:
6962. case LITERAL_long:
6963. case LITERAL_signed:
6964. case LITERAL_unsigned:
6965. case LITERAL_float:
6966. case LITERAL_double:
6967. case LITERAL_void:
6968. case OPERATOR:
6969. case LITERAL_this:
6970. case LITERAL_true:
6971. case LITERAL_false:
6972. case OCTALINT:
6973. case STAR:
6974. case AMPERSAND:
6975. case TILDE:
6976. case PLUS:
6977. case MINUS:
6978. case PLUSPLUS:
6979. case MINUSMINUS:
6980. case LITERAL_sizeof:
6981. case SCOPE:
6982. case LITERAL_dynamic_cast:
6983. case LITERAL_static_cast:
6984. case LITERAL_reinterpret_cast:
6985. case NOT:
6986. case LITERAL_new:
6987. case LITERAL_delete:
6988. case DECIMALINT:
6989. case HEXADECIMALINT:
6990. case CharLiteral:
6991. case FLOATONE:
6992. case FLOATTWO:
6993. {
6994. expression();
6995. break;
6996. }
6997. case SEMICOLON:
6998. {
6999. break;
7000. }
7001. default:
7002. {
7003. throw new NoViableAltException(LT(1), getFilename());
7004. }
7005. }
7006. }
7007. }
7008. else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_60.member(LA(2)))) {
7009. expression();
7010. }
7011. else if ((LA(1)==SEMICOLON)) {
7012. }
7013. else {
7014. throw new NoViableAltException(LT(1), getFilename());
7015. }
7016.
7017. }
7018. match(SEMICOLON);
7019. break;
7020. }
7021. default:
7022. {
7023. throw new NoViableAltException(LT(1), getFilename());
7024. }
7025. }
7026. }
7027. }
7028.
7029. public final void try_block() throws RecognitionException, TokenStreamException {
7030.
7031.
7032. match(LITERAL_try);
7033. compound_statement();
7034. {
7035. _loop334:
7036. do {
7037. if ((LA(1)==LITERAL_catch)) {
7038. handler();
7039. }
7040. else {
7041. break _loop334;
7042. }
7043.
7044. } while (true);
7045. }
7046. }
7047.
7048. public final void throw_statement() throws RecognitionException, TokenStreamException {
7049.
7050.
7051. match(LITERAL_throw);
7052. {
7053. switch ( LA(1)) {
7054. case ID:
7055. case StringLiteral:
7056. case LITERAL__declspec:
7057. case LITERAL___declspec:
7058. case LPAREN:
7059. case LITERAL_const_cast:
7060. case LITERAL_char:
7061. case LITERAL_wchar_t:
7062. case LITERAL_bool:
7063. case LITERAL_short:
7064. case LITERAL_int:
7065. case 44:
7066. case 45:
7067. case 46:
7068. case LITERAL_long:
7069. case LITERAL_signed:
7070. case LITERAL_unsigned:
7071. case LITERAL_float:
7072. case LITERAL_double:
7073. case LITERAL_void:
7074. case OPERATOR:
7075. case LITERAL_this:
7076. case LITERAL_true:
7077. case LITERAL_false:
7078. case OCTALINT:
7079. case STAR:
7080. case AMPERSAND:
7081. case TILDE:
7082. case PLUS:
7083. case MINUS:
7084. case PLUSPLUS:
7085. case MINUSMINUS:
7086. case LITERAL_sizeof:
7087. case SCOPE:
7088. case LITERAL_dynamic_cast:
7089. case LITERAL_static_cast:
7090. case LITERAL_reinterpret_cast:
7091. case NOT:
7092. case LITERAL_new:
7093. case LITERAL_delete:
7094. case DECIMALINT:
7095. case HEXADECIMALINT:
7096. case CharLiteral:
7097. case FLOATONE:
7098. case FLOATTWO:
7099. {
7100. assignment_expression();
7101. break;
7102. }
7103. case SEMICOLON:
7104. {
7105. break;
7106. }
7107. default:
7108. {
7109. throw new NoViableAltException(LT(1), getFilename());
7110. }
7111. }
7112. }
7113. match(SEMICOLON);
7114. }
7115.
7116. public final void asm_block() throws RecognitionException, TokenStreamException {
7117.
7118.
7119. {
7120. switch ( LA(1)) {
7121. case LITERAL__asm:
7122. {
7123. match(LITERAL__asm);
7124. break;
7125. }
7126. case LITERAL___asm:
7127. {
7128. match(LITERAL___asm);
7129. break;
7130. }
7131. default:
7132. {
7133. throw new NoViableAltException(LT(1), getFilename());
7134. }
7135. }
7136. }
7137. match(LCURLY);
7138. {
7139. _loop344:
7140. do {
7141. if ((_tokenSet_63.member(LA(1)))) {
7142. matchNot(RCURLY);
7143. }
7144. else {
7145. break _loop344;
7146. }
7147.
7148. } while (true);
7149. }
7150. match(RCURLY);
7151. }
7152.
7153. public final void handler() throws RecognitionException, TokenStreamException {
7154.
7155.
7156. match(LITERAL_catch);
7157. match(LPAREN);
7158. exception_declaration();
7159. match(RPAREN);
7160. compound_statement();
7161. }
7162.
7163. public final void exception_declaration() throws RecognitionException, TokenStreamException {
7164.
7165.
7166. parameter_declaration_list();
7167. }
7168.
7169. public final void assignment_expression() throws RecognitionException, TokenStreamException {
7170.
7171.
7172. conditional_expression();
7173. {
7174. switch ( LA(1)) {
7175. case ASSIGNEQUAL:
7176. case TIMESEQUAL:
7177. case DIVIDEEQUAL:
7178. case MINUSEQUAL:
7179. case PLUSEQUAL:
7180. case MODEQUAL:
7181. case SHIFTLEFTEQUAL:
7182. case SHIFTRIGHTEQUAL:
7183. case BITWISEANDEQUAL:
7184. case BITWISEXOREQUAL:
7185. case BITWISEOREQUAL:
7186. {
7187. {
7188. switch ( LA(1)) {
7189. case ASSIGNEQUAL:
7190. {
7191. match(ASSIGNEQUAL);
7192. break;
7193. }
7194. case TIMESEQUAL:
7195. {
7196. match(TIMESEQUAL);
7197. break;
7198. }
7199. case DIVIDEEQUAL:
7200. {
7201. match(DIVIDEEQUAL);
7202. break;
7203. }
7204. case MINUSEQUAL:
7205. {
7206. match(MINUSEQUAL);
7207. break;
7208. }
7209. case PLUSEQUAL:
7210. {
7211. match(PLUSEQUAL);
7212. break;
7213. }
7214. case MODEQUAL:
7215. {
7216. match(MODEQUAL);
7217. break;
7218. }
7219. case SHIFTLEFTEQUAL:
7220. {
7221. match(SHIFTLEFTEQUAL);
7222. break;
7223. }
7224. case SHIFTRIGHTEQUAL:
7225. {
7226. match(SHIFTRIGHTEQUAL);
7227. break;
7228. }
7229. case BITWISEANDEQUAL:
7230. {
7231. match(BITWISEANDEQUAL);
7232. break;
7233. }
7234. case BITWISEXOREQUAL:
7235. {
7236. match(BITWISEXOREQUAL);
7237. break;
7238. }
7239. case BITWISEOREQUAL:
7240. {
7241. match(BITWISEOREQUAL);
7242. break;
7243. }
7244. default:
7245. {
7246. throw new NoViableAltException(LT(1), getFilename());
7247. }
7248. }
7249. }
7250. remainder_expression();
7251. break;
7252. }
7253. case GREATERTHAN:
7254. case SEMICOLON:
7255. case RCURLY:
7256. case COLON:
7257. case COMMA:
7258. case RPAREN:
7259. case RSQUARE:
7260. case ELLIPSIS:
7261. {
7262. break;
7263. }
7264. default:
7265. {
7266. throw new NoViableAltException(LT(1), getFilename());
7267. }
7268. }
7269. }
7270. }
7271.
7272. public final void conditional_expression() throws RecognitionException, TokenStreamException {
7273.
7274.
7275. logical_or_expression();
7276. {
7277. switch ( LA(1)) {
7278. case QUESTIONMARK:
7279. {
7280. match(QUESTIONMARK);
7281. expression();
7282. match(COLON);
7283. conditional_expression();
7284. break;
7285. }
7286. case GREATERTHAN:
7287. case SEMICOLON:
7288. case RCURLY:
7289. case ASSIGNEQUAL:
7290. case COLON:
7291. case COMMA:
7292. case RPAREN:
7293. case RSQUARE:
7294. case ELLIPSIS:
7295. case TIMESEQUAL:
7296. case DIVIDEEQUAL:
7297. case MINUSEQUAL:
7298. case PLUSEQUAL:
7299. case MODEQUAL:
7300. case SHIFTLEFTEQUAL:
7301. case SHIFTRIGHTEQUAL:
7302. case BITWISEANDEQUAL:
7303. case BITWISEXOREQUAL:
7304. case BITWISEOREQUAL:
7305. {
7306. break;
7307. }
7308. default:
7309. {
7310. throw new NoViableAltException(LT(1), getFilename());
7311. }
7312. }
7313. }
7314. }
7315.
7316. public final void logical_or_expression() throws RecognitionException, TokenStreamException {
7317.
7318.
7319. logical_and_expression();
7320. {
7321. _loop361:
7322. do {
7323. if ((LA(1)==OR)) {
7324. match(OR);
7325. logical_and_expression();
7326. }
7327. else {
7328. break _loop361;
7329. }
7330.
7331. } while (true);
7332. }
7333. }
7334.
7335. public final void logical_and_expression() throws RecognitionException, TokenStreamException {
7336.
7337.
7338. inclusive_or_expression();
7339. {
7340. _loop364:
7341. do {
7342. if ((LA(1)==AND)) {
7343. match(AND);
7344. inclusive_or_expression();
7345. }
7346. else {
7347. break _loop364;
7348. }
7349.
7350. } while (true);
7351. }
7352. }
7353.
7354. public final void inclusive_or_expression() throws RecognitionException, TokenStreamException {
7355.
7356.
7357. exclusive_or_expression();
7358. {
7359. _loop367:
7360. do {
7361. if ((LA(1)==BITWISEOR)) {
7362. match(BITWISEOR);
7363. exclusive_or_expression();
7364. }
7365. else {
7366. break _loop367;
7367. }
7368.
7369. } while (true);
7370. }
7371. }
7372.
7373. public final void exclusive_or_expression() throws RecognitionException, TokenStreamException {
7374.
7375.
7376. and_expression();
7377. {
7378. _loop370:
7379. do {
7380. if ((LA(1)==BITWISEXOR)) {
7381. match(BITWISEXOR);
7382. and_expression();
7383. }
7384. else {
7385. break _loop370;
7386. }
7387.
7388. } while (true);
7389. }
7390. }
7391.
7392. public final void and_expression() throws RecognitionException, TokenStreamException {
7393.
7394.
7395. equality_expression();
7396. {
7397. _loop373:
7398. do {
7399. if ((LA(1)==AMPERSAND)) {
7400. match(AMPERSAND);
7401. equality_expression();
7402. }
7403. else {
7404. break _loop373;
7405. }
7406.
7407. } while (true);
7408. }
7409. }
7410.
7411. public final void equality_expression() throws RecognitionException, TokenStreamException {
7412.
7413.
7414. relational_expression();
7415. {
7416. _loop377:
7417. do {
7418. if ((LA(1)==NOTEQUAL||LA(1)==EQUAL)) {
7419. {
7420. switch ( LA(1)) {
7421. case NOTEQUAL:
7422. {
7423. match(NOTEQUAL);
7424. break;
7425. }
7426. case EQUAL:
7427. {
7428. match(EQUAL);
7429. break;
7430. }
7431. default:
7432. {
7433. throw new NoViableAltException(LT(1), getFilename());
7434. }
7435. }
7436. }
7437. relational_expression();
7438. }
7439. else {
7440. break _loop377;
7441. }
7442.
7443. } while (true);
7444. }
7445. }
7446.
7447. public final void relational_expression() throws RecognitionException, TokenStreamException {
7448.
7449.
7450. shift_expression();
7451. {
7452. _loop381:
7453. do {
7454. if ((_tokenSet_64.member(LA(1))) && (_tokenSet_42.member(LA(2)))) {
7455. {
7456. switch ( LA(1)) {
7457. case LESSTHAN:
7458. {
7459. match(LESSTHAN);
7460. break;
7461. }
7462. case GREATERTHAN:
7463. {
7464. match(GREATERTHAN);
7465. break;
7466. }
7467. case LESSTHANOREQUALTO:
7468. {
7469. match(LESSTHANOREQUALTO);
7470. break;
7471. }
7472. case GREATERTHANOREQUALTO:
7473. {
7474. match(GREATERTHANOREQUALTO);
7475. break;
7476. }
7477. default:
7478. {
7479. throw new NoViableAltException(LT(1), getFilename());
7480. }
7481. }
7482. }
7483. shift_expression();
7484. }
7485. else {
7486. break _loop381;
7487. }
7488.
7489. } while (true);
7490. }
7491. }
7492.
7493. public final void additive_expression() throws RecognitionException, TokenStreamException {
7494.
7495.
7496. multiplicative_expression();
7497. {
7498. _loop389:
7499. do {
7500. if ((LA(1)==PLUS||LA(1)==MINUS)) {
7501. {
7502. switch ( LA(1)) {
7503. case PLUS:
7504. {
7505. match(PLUS);
7506. break;
7507. }
7508. case MINUS:
7509. {
7510. match(MINUS);
7511. break;
7512. }
7513. default:
7514. {
7515. throw new NoViableAltException(LT(1), getFilename());
7516. }
7517. }
7518. }
7519. multiplicative_expression();
7520. }
7521. else {
7522. break _loop389;
7523. }
7524.
7525. } while (true);
7526. }
7527. }
7528.
7529. public final void multiplicative_expression() throws RecognitionException, TokenStreamException {
7530.
7531.
7532. pm_expression();
7533. {
7534. _loop393:
7535. do {
7536. if ((_tokenSet_65.member(LA(1)))) {
7537. {
7538. switch ( LA(1)) {
7539. case STAR:
7540. {
7541. match(STAR);
7542. break;
7543. }
7544. case DIVIDE:
7545. {
7546. match(DIVIDE);
7547. break;
7548. }
7549. case MOD:
7550. {
7551. match(MOD);
7552. break;
7553. }
7554. default:
7555. {
7556. throw new NoViableAltException(LT(1), getFilename());
7557. }
7558. }
7559. }
7560. pm_expression();
7561. }
7562. else {
7563. break _loop393;
7564. }
7565.
7566. } while (true);
7567. }
7568. }
7569.
7570. public final void pm_expression() throws RecognitionException, TokenStreamException {
7571.
7572.
7573. cast_expression();
7574. {
7575. _loop397:
7576. do {
7577. if ((LA(1)==DOTMBR||LA(1)==POINTERTOMBR)) {
7578. {
7579. switch ( LA(1)) {
7580. case DOTMBR:
7581. {
7582. match(DOTMBR);
7583. break;
7584. }
7585. case POINTERTOMBR:
7586. {
7587. match(POINTERTOMBR);
7588. break;
7589. }
7590. default:
7591. {
7592. throw new NoViableAltException(LT(1), getFilename());
7593. }
7594. }
7595. }
7596. cast_expression();
7597. }
7598. else {
7599. break _loop397;
7600. }
7601.
7602. } while (true);
7603. }
7604. }
7605.
7606. public final void cast_expression() throws RecognitionException, TokenStreamException {
7607.
7608.
7609. boolean synPredMatched402 = false;
7610. if (((LA(1)==LPAREN) && (_tokenSet_66.member(LA(2))))) {
7611. int _m402 = mark();
7612. synPredMatched402 = true;
7613. inputState.guessing++;
7614. try {
7615. {
7616. match(LPAREN);
7617. {
7618. switch ( LA(1)) {
7619. case LITERAL_const:
7620. case LITERAL_const_cast:
7621. case LITERAL_volatile:
7622. {
7623. type_qualifier();
7624. break;
7625. }
7626. case ID:
7627. case LITERAL__declspec:
7628. case LITERAL___declspec:
7629. case LITERAL_char:
7630. case LITERAL_wchar_t:
7631. case LITERAL_bool:
7632. case LITERAL_short:
7633. case LITERAL_int:
7634. case 44:
7635. case 45:
7636. case 46:
7637. case LITERAL_long:
7638. case LITERAL_signed:
7639. case LITERAL_unsigned:
7640. case LITERAL_float:
7641. case LITERAL_double:
7642. case LITERAL_void:
7643. case SCOPE:
7644. {
7645. break;
7646. }
7647. default:
7648. {
7649. throw new NoViableAltException(LT(1), getFilename());
7650. }
7651. }
7652. }
7653. simple_type_specifier();
7654. {
7655. switch ( LA(1)) {
7656. case ID:
7657. case LITERAL__stdcall:
7658. case LITERAL___stdcall:
7659. case STAR:
7660. case AMPERSAND:
7661. case SCOPE:
7662. case LITERAL__cdecl:
7663. case LITERAL___cdecl:
7664. case LITERAL__near:
7665. case LITERAL___near:
7666. case LITERAL__far:
7667. case LITERAL___far:
7668. case LITERAL___interrupt:
7669. case LITERAL_pascal:
7670. case LITERAL__pascal:
7671. case LITERAL___pascal:
7672. {
7673. ptr_operator();
7674. break;
7675. }
7676. case RPAREN:
7677. {
7678. break;
7679. }
7680. default:
7681. {
7682. throw new NoViableAltException(LT(1), getFilename());
7683. }
7684. }
7685. }
7686. match(RPAREN);
7687. }
7688. }
7689. catch (RecognitionException pe) {
7690. synPredMatched402 = false;
7691. }
7692. rewind(_m402);
7693. inputState.guessing--;
7694. }
7695. if ( synPredMatched402 ) {
7696. match(LPAREN);
7697. {
7698. switch ( LA(1)) {
7699. case LITERAL_const:
7700. case LITERAL_const_cast:
7701. case LITERAL_volatile:
7702. {
7703. type_qualifier();
7704. break;
7705. }
7706. case ID:
7707. case LITERAL__declspec:
7708. case LITERAL___declspec:
7709. case LITERAL_char:
7710. case LITERAL_wchar_t:
7711. case LITERAL_bool:
7712. case LITERAL_short:
7713. case LITERAL_int:
7714. case 44:
7715. case 45:
7716. case 46:
7717. case LITERAL_long:
7718. case LITERAL_signed:
7719. case LITERAL_unsigned:
7720. case LITERAL_float:
7721. case LITERAL_double:
7722. case LITERAL_void:
7723. case SCOPE:
7724. {
7725. break;
7726. }
7727. default:
7728. {
7729. throw new NoViableAltException(LT(1), getFilename());
7730. }
7731. }
7732. }
7733. simple_type_specifier();
7734. {
7735. switch ( LA(1)) {
7736. case ID:
7737. case LITERAL__stdcall:
7738. case LITERAL___stdcall:
7739. case STAR:
7740. case AMPERSAND:
7741. case SCOPE:
7742. case LITERAL__cdecl:
7743. case LITERAL___cdecl:
7744. case LITERAL__near:
7745. case LITERAL___near:
7746. case LITERAL__far:
7747. case LITERAL___far:
7748. case LITERAL___interrupt:
7749. case LITERAL_pascal:
7750. case LITERAL__pascal:
7751. case LITERAL___pascal:
7752. {
7753. ptr_operator();
7754. break;
7755. }
7756. case RPAREN:
7757. {
7758. break;
7759. }
7760. default:
7761. {
7762. throw new NoViableAltException(LT(1), getFilename());
7763. }
7764. }
7765. }
7766. match(RPAREN);
7767. cast_expression();
7768. }
7769. else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_43.member(LA(2)))) {
7770. unary_expression();
7771. }
7772. else {
7773. throw new NoViableAltException(LT(1), getFilename());
7774. }
7775.
7776. }
7777.
7778. public final void unary_expression() throws RecognitionException, TokenStreamException {
7779.
7780.
7781. {
7782. switch ( LA(1)) {
7783. case PLUSPLUS:
7784. {
7785. match(PLUSPLUS);
7786. unary_expression();
7787. break;
7788. }
7789. case MINUSMINUS:
7790. {
7791. match(MINUSMINUS);
7792. unary_expression();
7793. break;
7794. }
7795. case LITERAL_sizeof:
7796. {
7797. match(LITERAL_sizeof);
7798. {
7799. if (((LA(1)==LPAREN) && (_tokenSet_11.member(LA(2))))&&((!(((LA(1)==LPAREN&&(LA(2)==ID))))||(isTy...7800. match(LPAREN);
7801. type_name();
7802. match(RPAREN);
7803. }
7804. else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_43.member(LA(2)))) {
7805. unary_expression();
7806. }
7807. else {
7808. throw new NoViableAltException(LT(1), getFilename());
7809. }
7810.
7811. }
7812. break;
7813. }
7814. default:
7815. boolean synPredMatched408 = false;
7816. if (((_tokenSet_67.member(LA(1))) && (_tokenSet_68.member(LA(2))))) {
7817. int _m408 = mark();
7818. synPredMatched408 = true;
7819. inputState.guessing++;
7820. try {
7821. {
7822. postfix_expression();
7823. }
7824. }
7825. catch (RecognitionException pe) {
7826. synPredMatched408 = false;
7827. }
7828. rewind(_m408);
7829. inputState.guessing--;
7830. }
7831. if ( synPredMatched408 ) {
7832. postfix_expression();
7833. }
7834. else if ((_tokenSet_69.member(LA(1))) && (_tokenSet_42.member(LA(2)))) {
7835. unary_operator();
7836. cast_expression();
7837. }
7838. else if ((_tokenSet_70.member(LA(1))) && (_tokenSet_71.member(LA(2)))) {
7839. {
7840. switch ( LA(1)) {
7841. case SCOPE:
7842. {
7843. match(SCOPE);
7844. break;
7845. }
7846. case LITERAL_new:
7847. case LITERAL_delete:
7848. {
7849. break;
7850. }
7851. default:
7852. {
7853. throw new NoViableAltException(LT(1), getFilename());
7854. }
7855. }
7856. }
7857. {
7858. switch ( LA(1)) {
7859. case LITERAL_new:
7860. {
7861. new_expression();
7862. break;
7863. }
7864. case LITERAL_delete:
7865. {
7866. delete_expression();
7867. break;
7868. }
7869. default:
7870. {
7871. throw new NoViableAltException(LT(1), getFilename());
7872. }
7873. }
7874. }
7875. }
7876. else {
7877. throw new NoViableAltException(LT(1), getFilename());
7878. }
7879. }
7880. }
7881. }
7882.
7883. public final void postfix_expression() throws RecognitionException, TokenStreamException {
7884.
7885.
7886. {
7887. boolean synPredMatched415 = false;
7888. if ((((_tokenSet_55.member(LA(1))) && (_tokenSet_72.member(LA(2))))&&(!(LA(1)==LPAREN)))) {
7889. int _m415 = mark();
7890. synPredMatched415 = true;
7891. inputState.guessing++;
7892. try {
7893. {
7894. simple_type_specifier();
7895. match(LPAREN);
7896. match(RPAREN);
7897. match(LPAREN);
7898. }
7899. }
7900. catch (RecognitionException pe) {
7901. synPredMatched415 = false;
7902. }
7903. rewind(_m415);
7904. inputState.guessing--;
7905. }
7906. if ( synPredMatched415 ) {
7907. simple_type_specifier();
7908. match(LPAREN);
7909. match(RPAREN);
7910. match(LPAREN);
7911. {
7912. switch ( LA(1)) {
7913. case ID:
7914. case StringLiteral:
7915. case LITERAL__declspec:
7916. case LITERAL___declspec:
7917. case LPAREN:
7918. case LITERAL_const_cast:
7919. case LITERAL_char:
7920. case LITERAL_wchar_t:
7921. case LITERAL_bool:
7922. case LITERAL_short:
7923. case LITERAL_int:
7924. case 44:
7925. case 45:
7926. case 46:
7927. case LITERAL_long:
7928. case LITERAL_signed:
7929. case LITERAL_unsigned:
7930. case LITERAL_float:
7931. case LITERAL_double:
7932. case LITERAL_void:
7933. case OPERATOR:
7934. case LITERAL_this:
7935. case LITERAL_true:
7936. case LITERAL_false:
7937. case OCTALINT:
7938. case STAR:
7939. case AMPERSAND:
7940. case TILDE:
7941. case PLUS:
7942. case MINUS:
7943. case PLUSPLUS:
7944. case MINUSMINUS:
7945. case LITERAL_sizeof:
7946. case SCOPE:
7947. case LITERAL_dynamic_cast:
7948. case LITERAL_static_cast:
7949. case LITERAL_reinterpret_cast:
7950. case NOT:
7951. case LITERAL_new:
7952. case LITERAL_delete:
7953. case DECIMALINT:
7954. case HEXADECIMALINT:
7955. case CharLiteral:
7956. case FLOATONE:
7957. case FLOATTWO:
7958. {
7959. expression_list();
7960. break;
7961. }
7962. case RPAREN:
7963. {
7964. break;
7965. }
7966. default:
7967. {
7968. throw new NoViableAltException(LT(1), getFilename());
7969. }
7970. }
7971. }
7972. match(RPAREN);
7973. }
7974. else {
7975. boolean synPredMatched418 = false;
7976. if ((((_tokenSet_55.member(LA(1))) && (_tokenSet_72.member(LA(2))))&&(!(LA(1)==LPAREN)))) {
7977. int _m418 = mark();
7978. synPredMatched418 = true;
7979. inputState.guessing++;
7980. try {
7981. {
7982. simple_type_specifier();
7983. match(LPAREN);
7984. }
7985. }
7986. catch (RecognitionException pe) {
7987. synPredMatched418 = false;
7988. }
7989. rewind(_m418);
7990. inputState.guessing--;
7991. }
7992. if ( synPredMatched418 ) {
7993. simple_type_specifier();
7994. match(LPAREN);
7995. {
7996. switch ( LA(1)) {
7997. case ID:
7998. case StringLiteral:
7999. case LITERAL__declspec:
8000. case LITERAL___declspec:
8001. case LPAREN:
8002. case LITERAL_const_cast:
8003. case LITERAL_char:
8004. case LITERAL_wchar_t:
8005. case LITERAL_bool:
8006. case LITERAL_short:
8007. case LITERAL_int:
8008. case 44:
8009. case 45:
8010. case 46:
8011. case LITERAL_long:
8012. case LITERAL_signed:
8013. case LITERAL_unsigned:
8014. case LITERAL_float:
8015. case LITERAL_double:
8016. case LITERAL_void:
8017. case OPERATOR:
8018. case LITERAL_this:
8019. case LITERAL_true:
8020. case LITERAL_false:
8021. case OCTALINT:
8022. case STAR:
8023. case AMPERSAND:
8024. case TILDE:
8025. case PLUS:
8026. case MINUS:
8027. case PLUSPLUS:
8028. case MINUSMINUS:
8029. case LITERAL_sizeof:
8030. case SCOPE:
8031. case LITERAL_dynamic_cast:
8032. case LITERAL_static_cast:
8033. case LITERAL_reinterpret_cast:
8034. case NOT:
8035. case LITERAL_new:
8036. case LITERAL_delete:
8037. case DECIMALINT:
8038. case HEXADECIMALINT:
8039. case CharLiteral:
8040. case FLOATONE:
8041. case FLOATTWO:
8042. {
8043. expression_list();
8044. break;
8045. }
8046. case RPAREN:
8047. {
8048. break;
8049. }
8050. default:
8051. {
8052. throw new NoViableAltException(LT(1), getFilename());
8053. }
8054. }
8055. }
8056. match(RPAREN);
8057. }
8058. else if ((_tokenSet_73.member(LA(1))) && (_tokenSet_68.member(LA(2)))) {
8059. primary_expression();
8060. {
8061. _loop422:
8062. do {
8063. switch ( LA(1)) {
8064. case LSQUARE:
8065. {
8066. match(LSQUARE);
8067. expression();
8068. match(RSQUARE);
8069. break;
8070. }
8071. case LPAREN:
8072. {
8073. match(LPAREN);
8074. {
8075. switch ( LA(1)) {
8076. case ID:
8077. case StringLiteral:
8078. case LITERAL__declspec:
8079. case LITERAL___declspec:
8080. case LPAREN:
8081. case LITERAL_const_cast:
8082. case LITERAL_char:
8083. case LITERAL_wchar_t:
8084. case LITERAL_bool:
8085. case LITERAL_short:
8086. case LITERAL_int:
8087. case 44:
8088. case 45:
8089. case 46:
8090. case LITERAL_long:
8091. case LITERAL_signed:
8092. case LITERAL_unsigned:
8093. case LITERAL_float:
8094. case LITERAL_double:
8095. case LITERAL_void:
8096. case OPERATOR:
8097. case LITERAL_this:
8098. case LITERAL_true:
8099. case LITERAL_false:
8100. case OCTALINT:
8101. case STAR:
8102. case AMPERSAND:
8103. case TILDE:
8104. case PLUS:
8105. case MINUS:
8106. case PLUSPLUS:
8107. case MINUSMINUS:
8108. case LITERAL_sizeof:
8109. case SCOPE:
8110. case LITERAL_dynamic_cast:
8111. case LITERAL_static_cast:
8112. case LITERAL_reinterpret_cast:
8113. case NOT:
8114. case LITERAL_new:
8115. case LITERAL_delete:
8116. case DECIMALINT:
8117. case HEXADECIMALINT:
8118. case CharLiteral:
8119. case FLOATONE:
8120. case FLOATTWO:
8121. {
8122. expression_list();
8123. break;
8124. }
8125. case RPAREN:
8126. {
8127. break;
8128. }
8129. default:
8130. {
8131. throw new NoViableAltException(LT(1), getFilename());
8132. }
8133. }
8134. }
8135. match(RPAREN);
8136. break;
8137. }
8138. case DOT:
8139. {
8140. match(DOT);
8141. id_expression();
8142. break;
8143. }
8144. case POINTERTO:
8145. {
8146. match(POINTERTO);
8147. id_expression();
8148. break;
8149. }
8150. case PLUSPLUS:
8151. {
8152. match(PLUSPLUS);
8153. break;
8154. }
8155. case MINUSMINUS:
8156. {
8157. match(MINUSMINUS);
8158. break;
8159. }
8160. default:
8161. {
8162. break _loop422;
8163. }
8164. }
8165. } while (true);
8166. }
8167. }
8168. else if ((_tokenSet_74.member(LA(1)))) {
8169. {
8170. switch ( LA(1)) {
8171. case LITERAL_dynamic_cast:
8172. {
8173. match(LITERAL_dynamic_cast);
8174. break;
8175. }
8176. case LITERAL_static_cast:
8177. {
8178. match(LITERAL_static_cast);
8179. break;
8180. }
8181. case LITERAL_reinterpret_cast:
8182. {
8183. match(LITERAL_reinterpret_cast);
8184. break;
8185. }
8186. case LITERAL_const_cast:
8187. {
8188. match(LITERAL_const_cast);
8189. break;
8190. }
8191. default:
8192. {
8193. throw new NoViableAltException(LT(1), getFilename());
8194. }
8195. }
8196. }
8197. match(LESSTHAN);
8198. type_specifier();
8199. {
8200. switch ( LA(1)) {
8201. case ID:
8202. case LITERAL__stdcall:
8203. case LITERAL___stdcall:
8204. case STAR:
8205. case AMPERSAND:
8206. case SCOPE:
8207. case LITERAL__cdecl:
8208. case LITERAL___cdecl:
8209. case LITERAL__near:
8210. case LITERAL___near:
8211. case LITERAL__far:
8212. case LITERAL___far:
8213. case LITERAL___interrupt:
8214. case LITERAL_pascal:
8215. case LITERAL__pascal:
8216. case LITERAL___pascal:
8217. {
8218. ptr_operator();
8219. break;
8220. }
8221. case GREATERTHAN:
8222. {
8223. break;
8224. }
8225. default:
8226. {
8227. throw new NoViableAltException(LT(1), getFilename());
8228. }
8229. }
8230. }
8231. match(GREATERTHAN);
8232. match(LPAREN);
8233. expression();
8234. match(RPAREN);
8235. }
8236. else {
8237. throw new NoViableAltException(LT(1), getFilename());
8238. }
8239. }
8240. }
8241. }
8242.
8243. public final void unary_operator() throws RecognitionException, TokenStreamException {
8244.
8245.
8246. switch ( LA(1)) {
8247. case AMPERSAND:
8248. {
8249. match(AMPERSAND);
8250. break;
8251. }
8252. case STAR:
8253. {
8254. match(STAR);
8255. break;
8256. }
8257. case PLUS:
8258. {
8259. match(PLUS);
8260. break;
8261. }
8262. case MINUS:
8263. {
8264. match(MINUS);
8265. break;
8266. }
8267. case TILDE:
8268. {
8269. match(TILDE);
8270. break;
8271. }
8272. case NOT:
8273. {
8274. match(NOT);
8275. break;
8276. }
8277. default:
8278. {
8279. throw new NoViableAltException(LT(1), getFilename());
8280. }
8281. }
8282. }
8283.
8284. public final void new_expression() throws RecognitionException, TokenStreamException {
8285.
8286.
8287. {
8288. match(LITERAL_new);
8289. {
8290. boolean synPredMatched434 = false;
8291. if (((LA(1)==LPAREN) && (_tokenSet_42.member(LA(2))))) {
8292. int _m434 = mark();
8293. synPredMatched434 = true;
8294. inputState.guessing++;
8295. try {
8296. {
8297. match(LPAREN);
8298. expression_list();
8299. match(RPAREN);
8300. }
8301. }
8302. catch (RecognitionException pe) {
8303. synPredMatched434 = false;
8304. }
8305. rewind(_m434);
8306. inputState.guessing--;
8307. }
8308. if ( synPredMatched434 ) {
8309. match(LPAREN);
8310. expression_list();
8311. match(RPAREN);
8312. }
8313. else if ((_tokenSet_75.member(LA(1))) && (_tokenSet_76.member(LA(2)))) {
8314. }
8315. else {
8316. throw new NoViableAltException(LT(1), getFilename());
8317. }
8318.
8319. }
8320. {
8321. switch ( LA(1)) {
8322. case LITERAL_typedef:
8323. case LITERAL_enum:
8324. case ID:
8325. case LITERAL_inline:
8326. case LITERAL_extern:
8327. case LITERAL__inline:
8328. case LITERAL___inline:
8329. case LITERAL_virtual:
8330. case LITERAL_explicit:
8331. case LITERAL_friend:
8332. case LITERAL__stdcall:
8333. case LITERAL___stdcall:
8334. case LITERAL__declspec:
8335. case LITERAL___declspec:
8336. case LITERAL_typename:
8337. case LITERAL_auto:
8338. case LITERAL_register:
8339. case LITERAL_static:
8340. case LITERAL_mutable:
8341. case LITERAL_const:
8342. case LITERAL_const_cast:
8343. case LITERAL_volatile:
8344. case LITERAL_char:
8345. case LITERAL_wchar_t:
8346. case LITERAL_bool:
8347. case LITERAL_short:
8348. case LITERAL_int:
8349. case 44:
8350. case 45:
8351. case 46:
8352. case LITERAL_long:
8353. case LITERAL_signed:
8354. case LITERAL_unsigned:
8355. case LITERAL_float:
8356. case LITERAL_double:
8357. case LITERAL_void:
8358. case LITERAL_class:
8359. case LITERAL_struct:
8360. case LITERAL_union:
8361. case SCOPE:
8362. {
8363. new_type_id();
8364. break;
8365. }
8366. case LPAREN:
8367. {
8368. match(LPAREN);
8369. type_name();
8370. match(RPAREN);
8371. break;
8372. }
8373. default:
8374. {
8375. throw new NoViableAltException(LT(1), getFilename());
8376. }
8377. }
8378. }
8379. {
8380. switch ( LA(1)) {
8381. case LPAREN:
8382. {
8383. new_initializer();
8384. break;
8385. }
8386. case LESSTHAN:
8387. case GREATERTHAN:
8388. case SEMICOLON:
8389. case RCURLY:
8390. case ASSIGNEQUAL:
8391. case COLON:
8392. case COMMA:
8393. case RPAREN:
8394. case STAR:
8395. case AMPERSAND:
8396. case RSQUARE:
8397. case ELLIPSIS:
8398. case TIMESEQUAL:
8399. case DIVIDEEQUAL:
8400. case MINUSEQUAL:
8401. case PLUSEQUAL:
8402. case MODEQUAL:
8403. case SHIFTLEFTEQUAL:
8404. case SHIFTRIGHTEQUAL:
8405. case BITWISEANDEQUAL:
8406. case BITWISEXOREQUAL:
8407. case BITWISEOREQUAL:
8408. case QUESTIONMARK:
8409. case OR:
8410. case AND:
8411. case BITWISEOR:
8412. case BITWISEXOR:
8413. case NOTEQUAL:
8414. case EQUAL:
8415. case LESSTHANOREQUALTO:
8416. case GREATERTHANOREQUALTO:
8417. case SHIFTLEFT:
8418. case SHIFTRIGHT:
8419. case PLUS:
8420. case MINUS:
8421. case DIVIDE:
8422. case MOD:
8423. case DOTMBR:
8424. case POINTERTOMBR:
8425. {
8426. break;
8427. }
8428. default:
8429. {
8430. throw new NoViableAltException(LT(1), getFilename());
8431. }
8432. }
8433. }
8434. }
8435. }
8436.
8437. public final void delete_expression() throws RecognitionException, TokenStreamException {
8438.
8439.
8440. match(LITERAL_delete);
8441. {
8442. switch ( LA(1)) {
8443. case LSQUARE:
8444. {
8445. match(LSQUARE);
8446. match(RSQUARE);
8447. break;
8448. }
8449. case ID:
8450. case StringLiteral:
8451. case LITERAL__declspec:
8452. case LITERAL___declspec:
8453. case LPAREN:
8454. case LITERAL_const_cast:
8455. case LITERAL_char:
8456. case LITERAL_wchar_t:
8457. case LITERAL_bool:
8458. case LITERAL_short:
8459. case LITERAL_int:
8460. case 44:
8461. case 45:
8462. case 46:
8463. case LITERAL_long:
8464. case LITERAL_signed:
8465. case LITERAL_unsigned:
8466. case LITERAL_float:
8467. case LITERAL_double:
8468. case LITERAL_void:
8469. case OPERATOR:
8470. case LITERAL_this:
8471. case LITERAL_true:
8472. case LITERAL_false:
8473. case OCTALINT:
8474. case STAR:
8475. case AMPERSAND:
8476. case TILDE:
8477. case PLUS:
8478. case MINUS:
8479. case PLUSPLUS:
8480. case MINUSMINUS:
8481. case LITERAL_sizeof:
8482. case SCOPE:
8483. case LITERAL_dynamic_cast:
8484. case LITERAL_static_cast:
8485. case LITERAL_reinterpret_cast:
8486. case NOT:
8487. case LITERAL_new:
8488. case LITERAL_delete:
8489. case DECIMALINT:
8490. case HEXADECIMALINT:
8491. case CharLiteral:
8492. case FLOATONE:
8493. case FLOATTWO:
8494. {
8495. break;
8496. }
8497. default:
8498. {
8499. throw new NoViableAltException(LT(1), getFilename());
8500. }
8501. }
8502. }
8503. cast_expression();
8504. }
8505.
8506. public final void primary_expression() throws RecognitionException, TokenStreamException {
8507.
8508.
8509. switch ( LA(1)) {
8510. case ID:
8511. case OPERATOR:
8512. case TILDE:
8513. case SCOPE:
8514. {
8515. id_expression();
8516. break;
8517. }
8518. case StringLiteral:
8519. case LITERAL_true:
8520. case LITERAL_false:
8521. case OCTALINT:
8522. case DECIMALINT:
8523. case HEXADECIMALINT:
8524. case CharLiteral:
8525. case FLOATONE:
8526. case FLOATTWO:
8527. {
8528. constant();
8529. break;
8530. }
8531. case LITERAL_this:
8532. {
8533. match(LITERAL_this);
8534. break;
8535. }
8536. case LPAREN:
8537. {
8538. match(LPAREN);
8539. expression();
8540. match(RPAREN);
8541. break;
8542. }
8543. default:
8544. {
8545. throw new NoViableAltException(LT(1), getFilename());
8546. }
8547. }
8548. }
8549.
8550. public final void id_expression() throws RecognitionException, TokenStreamException {
8551.
8552. String s="";
8553.
8554. s=scope_override();
8555. {
8556. switch ( LA(1)) {
8557. case ID:
8558. {
8559. match(ID);
8560. break;
8561. }
8562. case OPERATOR:
8563. {
8564. match(OPERATOR);
8565. optor();
8566. break;
8567. }
8568. case TILDE:
8569. {
8570. match(TILDE);
8571. {
8572. switch ( LA(1)) {
8573. case STAR:
8574. {
8575. match(STAR);
8576. break;
8577. }
8578. case ID:
8579. {
8580. break;
8581. }
8582. default:
8583. {
8584. throw new NoViableAltException(LT(1), getFilename());
8585. }
8586. }
8587. }
8588. match(ID);
8589. break;
8590. }
8591. default:
8592. {
8593. throw new NoViableAltException(LT(1), getFilename());
8594. }
8595. }
8596. }
8597. }
8598.
8599. public final void constant() throws RecognitionException, TokenStreamException {
8600.
8601.
8602. switch ( LA(1)) {
8603. case OCTALINT:
8604. {
8605. match(OCTALINT);
8606. break;
8607. }
8608. case DECIMALINT:
8609. {
8610. match(DECIMALINT);
8611. break;
8612. }
8613. case HEXADECIMALINT:
8614. {
8615. match(HEXADECIMALINT);
8616. break;
8617. }
8618. case CharLiteral:
8619. {
8620. match(CharLiteral);
8621. break;
8622. }
8623. case StringLiteral:
8624. {
8625. {
8626. int _cnt468=0;
8627. _loop468:
8628. do {
8629. if ((LA(1)==StringLiteral)) {
8630. match(StringLiteral);
8631. }
8632. else {
8633. if ( _cnt468>=1 ) { break _loop468; } else {throw new NoViableAltException(LT(1), getFilename()...8634. }
8635.
8636. _cnt468++;
8637. } while (true);
8638. }
8639. break;
8640. }
8641. case FLOATONE:
8642. {
8643. match(FLOATONE);
8644. break;
8645. }
8646. case FLOATTWO:
8647. {
8648. match(FLOATTWO);
8649. break;
8650. }
8651. case LITERAL_true:
8652. {
8653. match(LITERAL_true);
8654. break;
8655. }
8656. case LITERAL_false:
8657. {
8658. match(LITERAL_false);
8659. break;
8660. }
8661. default:
8662. {
8663. throw new NoViableAltException(LT(1), getFilename());
8664. }
8665. }
8666. }
8667.
8668. public final void new_type_id() throws RecognitionException, TokenStreamException {
8669.
8670.
8671. declaration_specifiers();
8672. {
8673. if ((_tokenSet_77.member(LA(1))) && (_tokenSet_78.member(LA(2)))) {
8674. new_declarator();
8675. }
8676. else if ((_tokenSet_79.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
8677. }
8678. else {
8679. throw new NoViableAltException(LT(1), getFilename());
8680. }
8681.
8682. }
8683. }
8684.
8685. public final void new_initializer() throws RecognitionException, TokenStreamException {
8686.
8687.
8688. match(LPAREN);
8689. {
8690. switch ( LA(1)) {
8691. case ID:
8692. case StringLiteral:
8693. case LITERAL__declspec:
8694. case LITERAL___declspec:
8695. case LPAREN:
8696. case LITERAL_const_cast:
8697. case LITERAL_char:
8698. case LITERAL_wchar_t:
8699. case LITERAL_bool:
8700. case LITERAL_short:
8701. case LITERAL_int:
8702. case 44:
8703. case 45:
8704. case 46:
8705. case LITERAL_long:
8706. case LITERAL_signed:
8707. case LITERAL_unsigned:
8708. case LITERAL_float:
8709. case LITERAL_double:
8710. case LITERAL_void:
8711. case OPERATOR:
8712. case LITERAL_this:
8713. case LITERAL_true:
8714. case LITERAL_false:
8715. case OCTALINT:
8716. case STAR:
8717. case AMPERSAND:
8718. case TILDE:
8719. case PLUS:
8720. case MINUS:
8721. case PLUSPLUS:
8722. case MINUSMINUS:
8723. case LITERAL_sizeof:
8724. case SCOPE:
8725. case LITERAL_dynamic_cast:
8726. case LITERAL_static_cast:
8727. case LITERAL_reinterpret_cast:
8728. case NOT:
8729. case LITERAL_new:
8730. case LITERAL_delete:
8731. case DECIMALINT:
8732. case HEXADECIMALINT:
8733. case CharLiteral:
8734. case FLOATONE:
8735. case FLOATTWO:
8736. {
8737. expression_list();
8738. break;
8739. }
8740. case RPAREN:
8741. {
8742. break;
8743. }
8744. default:
8745. {
8746. throw new NoViableAltException(LT(1), getFilename());
8747. }
8748. }
8749. }
8750. match(RPAREN);
8751. }
8752.
8753. public final void new_declarator() throws RecognitionException, TokenStreamException {
8754.
8755.
8756. switch ( LA(1)) {
8757. case ID:
8758. case LITERAL__stdcall:
8759. case LITERAL___stdcall:
8760. case STAR:
8761. case AMPERSAND:
8762. case SCOPE:
8763. case LITERAL__cdecl:
8764. case LITERAL___cdecl:
8765. case LITERAL__near:
8766. case LITERAL___near:
8767. case LITERAL__far:
8768. case LITERAL___far:
8769. case LITERAL___interrupt:
8770. case LITERAL_pascal:
8771. case LITERAL__pascal:
8772. case LITERAL___pascal:
8773. {
8774. ptr_operator();
8775. {
8776. if ((_tokenSet_77.member(LA(1))) && (_tokenSet_78.member(LA(2)))) {
8777. new_declarator();
8778. }
8779. else if ((_tokenSet_79.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
8780. }
8781. else {
8782. throw new NoViableAltException(LT(1), getFilename());
8783. }
8784.
8785. }
8786. break;
8787. }
8788. case LSQUARE:
8789. {
8790. direct_new_declarator();
8791. break;
8792. }
8793. default:
8794. {
8795. throw new NoViableAltException(LT(1), getFilename());
8796. }
8797. }
8798. }
8799.
8800. public final void direct_new_declarator() throws RecognitionException, TokenStreamException {
8801.
8802.
8803. {
8804. int _cnt460=0;
8805. _loop460:
8806. do {
8807. if ((LA(1)==LSQUARE)) {
8808. match(LSQUARE);
8809. expression();
8810. match(RSQUARE);
8811. }
8812. else {
8813. if ( _cnt460>=1 ) { break _loop460; } else {throw new NoViableAltException(LT(1), getFilename())...8814. }
8815.
8816. _cnt460++;
8817. } while (true);
8818. }
8819. }
8820.
8821. public final void ptr_to_member() throws RecognitionException, TokenStreamException {
8822.
8823. String s="";
8824.
8825. s=scope_override();
8826. match(STAR);
8827. if ( inputState.guessing==0 ) {
8828.
8829. if (s.length() != 0) m.ptrToMember(s, "*");
8830. else m.ptrOperator("*");
8831.
8832. }
8833. cv_qualifier_seq();
8834. }
8835.
8836. public final void optor_simple_tokclass() throws RecognitionException, TokenStreamException {
8837.
8838.
8839. {
8840. switch ( LA(1)) {
8841. case PLUS:
8842. {
8843. match(PLUS);
8844. break;
8845. }
8846. case MINUS:
8847. {
8848. match(MINUS);
8849. break;
8850. }
8851. case STAR:
8852. {
8853. match(STAR);
8854. break;
8855. }
8856. case DIVIDE:
8857. {
8858. match(DIVIDE);
8859. break;
8860. }
8861. case MOD:
8862. {
8863. match(MOD);
8864. break;
8865. }
8866. case BITWISEXOR:
8867. {
8868. match(BITWISEXOR);
8869. break;
8870. }
8871. case AMPERSAND:
8872. {
8873. match(AMPERSAND);
8874. break;
8875. }
8876. case BITWISEOR:
8877. {
8878. match(BITWISEOR);
8879. break;
8880. }
8881. case TILDE:
8882. {
8883. match(TILDE);
8884. break;
8885. }
8886. case NOT:
8887. {
8888. match(NOT);
8889. break;
8890. }
8891. case SHIFTLEFT:
8892. {
8893. match(SHIFTLEFT);
8894. break;
8895. }
8896. case SHIFTRIGHT:
8897. {
8898. match(SHIFTRIGHT);
8899. break;
8900. }
8901. case ASSIGNEQUAL:
8902. {
8903. match(ASSIGNEQUAL);
8904. break;
8905. }
8906. case TIMESEQUAL:
8907. {
8908. match(TIMESEQUAL);
8909. break;
8910. }
8911. case DIVIDEEQUAL:
8912. {
8913. match(DIVIDEEQUAL);
8914. break;
8915. }
8916. case MODEQUAL:
8917. {
8918. match(MODEQUAL);
8919. break;
8920. }
8921. case PLUSEQUAL:
8922. {
8923. match(PLUSEQUAL);
8924. break;
8925. }
8926. case MINUSEQUAL:
8927. {
8928. match(MINUSEQUAL);
8929. break;
8930. }
8931. case SHIFTLEFTEQUAL:
8932. {
8933. match(SHIFTLEFTEQUAL);
8934. break;
8935. }
8936. case SHIFTRIGHTEQUAL:
8937. {
8938. match(SHIFTRIGHTEQUAL);
8939. break;
8940. }
8941. case BITWISEANDEQUAL:
8942. {
8943. match(BITWISEANDEQUAL);
8944. break;
8945. }
8946. case BITWISEXOREQUAL:
8947. {
8948. match(BITWISEXOREQUAL);
8949. break;
8950. }
8951. case BITWISEOREQUAL:
8952. {
8953. match(BITWISEOREQUAL);
8954. break;
8955. }
8956. case EQUAL:
8957. {
8958. match(EQUAL);
8959. break;
8960. }
8961. case NOTEQUAL:
8962. {
8963. match(NOTEQUAL);
8964. break;
8965. }
8966. case LESSTHAN:
8967. {
8968. match(LESSTHAN);
8969. break;
8970. }
8971. case GREATERTHAN:
8972. {
8973. match(GREATERTHAN);
8974. break;
8975. }
8976. case LESSTHANOREQUALTO:
8977. {
8978. match(LESSTHANOREQUALTO);
8979. break;
8980. }
8981. case GREATERTHANOREQUALTO:
8982. {
8983. match(GREATERTHANOREQUALTO);
8984. break;
8985. }
8986. case OR:
8987. {
8988. match(OR);
8989. break;
8990. }
8991. case AND:
8992. {
8993. match(AND);
8994. break;
8995. }
8996. case PLUSPLUS:
8997. {
8998. match(PLUSPLUS);
8999. break;
9000. }
9001. case MINUSMINUS:
9002. {
9003. match(MINUSMINUS);
9004. break;
9005. }
9006. case COMMA:
9007. {
9008. match(COMMA);
9009. break;
9010. }
9011. case POINTERTO:
9012. {
9013. match(POINTERTO);
9014. break;
9015. }
9016. case POINTERTOMBR:
9017. {
9018. match(POINTERTOMBR);
9019. break;
9020. }
9021. default:
9022. {
9023. throw new NoViableAltException(LT(1), getFilename());
9024. }
9025. }
9026. }
9027. }
9028.
9029.
9030. public static final String[] _tokenNames = {
9031. "<0>",
9032. "EOF",
9033. "<2>",
9034. "NULL_TREE_LOOKAHEAD",
9035. "\"template\"",
9036. "LESSTHAN",
9037. "GREATERTHAN",
9038. "\"typedef\"",
9039. "\"enum\"",
9040. "ID",
9041. "LCURLY",
9042. "SEMICOLON",
9043. "\"inline\"",
9044. "\"namespace\"",
9045. "RCURLY",
9046. "ASSIGNEQUAL",
9047. "COLON",
9048. "\"extern\"",
9049. "StringLiteral",
9050. "COMMA",
9051. "\"_inline\"",
9052. "\"__inline\"",
9053. "\"virtual\"",
9054. "\"explicit\"",
9055. "\"friend\"",
9056. "\"_stdcall\"",
9057. "\"__stdcall\"",
9058. "\"_declspec\"",
9059. "\"__declspec\"",
9060. "LPAREN",
9061. "RPAREN",
9062. "\"typename\"",
9063. "\"auto\"",
9064. "\"register\"",
9065. "\"static\"",
9066. "\"mutable\"",
9067. "\"const\"",
9068. "\"const_cast\"",
9069. "\"volatile\"",
9070. "\"char\"",
9071. "\"wchar_t\"",
9072. "\"bool\"",
9073. "\"short\"",
9074. "\"int\"",
9075. "\"_int64\"",
9076. "\"__int64\"",
9077. "\"__w64\"",
9078. "\"long\"",
9079. "\"signed\"",
9080. "\"unsigned\"",
9081. "\"float\"",
9082. "\"double\"",
9083. "\"void\"",
9084. "\"class\"",
9085. "\"struct\"",
9086. "\"union\"",
9087. "\"operator\"",
9088. "\"this\"",
9089. "\"true\"",
9090. "\"false\"",
9091. "\"public\"",
9092. "\"protected\"",
9093. "\"private\"",
9094. "OCTALINT",
9095. "STAR",
9096. "AMPERSAND",
9097. "LSQUARE",
9098. "RSQUARE",
9099. "TILDE",
9100. "ELLIPSIS",
9101. "\"throw\"",
9102. "\"case\"",
9103. "\"default\"",
9104. "\"if\"",
9105. "\"else\"",
9106. "\"switch\"",
9107. "\"while\"",
9108. "\"do\"",
9109. "\"for\"",
9110. "\"goto\"",
9111. "\"continue\"",
9112. "\"break\"",
9113. "\"return\"",
9114. "\"try\"",
9115. "\"catch\"",
9116. "\"using\"",
9117. "\"_asm\"",
9118. "\"__asm\"",
9119. "TIMESEQUAL",
9120. "DIVIDEEQUAL",
9121. "MINUSEQUAL",
9122. "PLUSEQUAL",
9123. "MODEQUAL",
9124. "SHIFTLEFTEQUAL",
9125. "SHIFTRIGHTEQUAL",
9126. "BITWISEANDEQUAL",
9127. "BITWISEXOREQUAL",
9128. "BITWISEOREQUAL",
9129. "QUESTIONMARK",
9130. "OR",
9131. "AND",
9132. "BITWISEOR",
9133. "BITWISEXOR",
9134. "NOTEQUAL",
9135. "EQUAL",
9136. "LESSTHANOREQUALTO",
9137. "GREATERTHANOREQUALTO",
9138. "SHIFTLEFT",
9139. "SHIFTRIGHT",
9140. "PLUS",
9141. "MINUS",
9142. "DIVIDE",
9143. "MOD",
9144. "DOTMBR",
9145. "POINTERTOMBR",
9146. "PLUSPLUS",
9147. "MINUSMINUS",
9148. "\"sizeof\"",
9149. "SCOPE",
9150. "DOT",
9151. "POINTERTO",
9152. "\"dynamic_cast\"",
9153. "\"static_cast\"",
9154. "\"reinterpret_cast\"",
9155. "NOT",
9156. "\"new\"",
9157. "\"_cdecl\"",
9158. "\"__cdecl\"",
9159. "\"_near\"",
9160. "\"__near\"",
9161. "\"_far\"",
9162. "\"__far\"",
9163. "\"__interrupt\"",
9164. "\"pascal\"",
9165. "\"_pascal\"",
9166. "\"__pascal\"",
9167. "\"delete\"",
9168. "DECIMALINT",
9169. "HEXADECIMALINT",
9170. "CharLiteral",
9171. "FLOATONE",
9172. "FLOATTWO",
9173. "Whitespace",
9174. "Comment",
9175. "CPPComment",
9176. "DIRECTIVE",
9177. "LineDirective",
9178. "EndOfLine",
9179. "Escape",
9180. "Digit",
9181. "Decimal",
9182. "LongSuffix",
9183. "UnsignedSuffix",
9184. "FloatSuffix",
9185. "Exponent",
9186. "Vocabulary",
9187. "Number"
9188. };
9189.
9190. private static final long[] mk_tokenSet_0() {
9191. long[] data = { 1152921503532202896L, -4593671619915808749L, 255L, 0L, 0L, 0L};
9192. return data;
9193. }
9194. public static final BitSet _tokenSet_0 = new BitSet(mk_tokenSet_0());
9195. private static final long[] mk_tokenSet_1() {
9196. long[] data = { 72057592426402688L, 18014398511579136L, 0L, 0L};
9197. return data;
9198. }
9199. public static final BitSet _tokenSet_1 = new BitSet(mk_tokenSet_1());
9200. private static final long[] mk_tokenSet_2() {
9201. long[] data = { 1152921501385506720L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9202. return data;
9203. }
9204. public static final BitSet _tokenSet_2 = new BitSet(mk_tokenSet_2());
9205. private static final long[] mk_tokenSet_3() {
9206. long[] data = { 7344656L, 18014398509482000L, 0L, 0L};
9207. return data;
9208. }
9209. public static final BitSet _tokenSet_3 = new BitSet(mk_tokenSet_3());
9210. private static final long[] mk_tokenSet_4() {
9211. long[] data = { 7344672L, 18014398509482000L, 0L, 0L};
9212. return data;
9213. }
9214. public static final BitSet _tokenSet_4 = new BitSet(mk_tokenSet_4());
9215. private static final long[] mk_tokenSet_5() {
9216. long[] data = { 11538944L, 18014398509481984L, 0L, 0L};
9217. return data;
9218. }
9219. public static final BitSet _tokenSet_5 = new BitSet(mk_tokenSet_5());
9220. private static final long[] mk_tokenSet_6() {
9221. long[] data = { 548409888L, 18014398509481984L, 0L, 0L};
9222. return data;
9223. }
9224. public static final BitSet _tokenSet_6 = new BitSet(mk_tokenSet_6());
9225. private static final long[] mk_tokenSet_7() {
9226. long[] data = { 72057594037932544L, 18014398509481984L, 0L, 0L};
9227. return data;
9228. }
9229. public static final BitSet _tokenSet_7 = new BitSet(mk_tokenSet_7());
9230. private static final long[] mk_tokenSet_8() {
9231. long[] data = { 144115186464330656L, 18014398509481984L, 0L, 0L};
9232. return data;
9233. }
9234. public static final BitSet _tokenSet_8 = new BitSet(mk_tokenSet_8());
9235. private static final long[] mk_tokenSet_9() {
9236. long[] data = { 1152921503532192640L, -4593671619917905917L, 255L, 0L, 0L, 0L};
9237. return data;
9238. }
9239. public static final BitSet _tokenSet_9 = new BitSet(mk_tokenSet_9());
9240. private static final long[] mk_tokenSet_10() {
9241. long[] data = { 1152921501385267168L, -1054405279954763753L, 511L, 0L, 0L, 0L};
9242. return data;
9243. }
9244. public static final BitSet _tokenSet_10 = new BitSet(mk_tokenSet_10());
9245. private static final long[] mk_tokenSet_11() {
9246. long[] data = { 72057592426402688L, 18014398509481984L, 0L, 0L};
9247. return data;
9248. }
9249. public static final BitSet _tokenSet_11 = new BitSet(mk_tokenSet_11());
9250. private static final long[] mk_tokenSet_12() {
9251. long[] data = { 1152921501385236384L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9252. return data;
9253. }
9254. public static final BitSet _tokenSet_12 = new BitSet(mk_tokenSet_12());
9255. private static final long[] mk_tokenSet_13() {
9256. long[] data = { 100663808L, -4593671619917905917L, 255L, 0L, 0L, 0L};
9257. return data;
9258. }
9259. public static final BitSet _tokenSet_13 = new BitSet(mk_tokenSet_13());
9260. private static final long[] mk_tokenSet_14() {
9261. long[] data = { 1080864392242790944L, -4593671619917905917L, 255L, 0L, 0L, 0L};
9262. return data;
9263. }
9264. public static final BitSet _tokenSet_14 = new BitSet(mk_tokenSet_14());
9265. private static final long[] mk_tokenSet_15() {
9266. long[] data = { 1080863911105790464L, 18014398509481984L, 0L, 0L};
9267. return data;
9268. }
9269. public static final BitSet _tokenSet_15 = new BitSet(mk_tokenSet_15());
9270. private static final long[] mk_tokenSet_16() {
9271. long[] data = { 1080863911106347616L, 3557280738472624151L, 256L, 0L, 0L, 0L};
9272. return data;
9273. }
9274. public static final BitSet _tokenSet_16 = new BitSet(mk_tokenSet_16());
9275. private static final long[] mk_tokenSet_17() {
9276. long[] data = { 1152921501384710048L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9277. return data;
9278. }
9279. public static final BitSet _tokenSet_17 = new BitSet(mk_tokenSet_17());
9280. private static final long[] mk_tokenSet_18() {
9281. long[] data = { 72057592426403712L, 18014398511579136L, 0L, 0L};
9282. return data;
9283. }
9284. public static final BitSet _tokenSet_18 = new BitSet(mk_tokenSet_18());
9285. private static final long[] mk_tokenSet_19() {
9286. long[] data = { -8070450533321769056L, -110232637738583085L, 16383L, 0L, 0L, 0L};
9287. return data;
9288. }
9289. public static final BitSet _tokenSet_19 = new BitSet(mk_tokenSet_19());
9290. private static final long[] mk_tokenSet_20() {
9291. long[] data = { -8070450533322301568L, 4501453380688804819L, 16128L, 0L, 0L, 0L};
9292. return data;
9293. }
9294. public static final BitSet _tokenSet_20 = new BitSet(mk_tokenSet_20());
9295. private static final long[] mk_tokenSet_21() {
9296. long[] data = { 1080863911206453760L, -4593671619917905917L, 255L, 0L, 0L, 0L};
9297. return data;
9298. }
9299. public static final BitSet _tokenSet_21 = new BitSet(mk_tokenSet_21());
9300. private static final long[] mk_tokenSet_22() {
9301. long[] data = { 1080864392243348064L, -1054405279954763753L, 511L, 0L, 0L, 0L};
9302. return data;
9303. }
9304. public static final BitSet _tokenSet_22 = new BitSet(mk_tokenSet_22());
9305. private static final long[] mk_tokenSet_23() {
9306. long[] data = { 1152921503532220304L, -4593671619915808749L, 255L, 0L, 0L, 0L};
9307. return data;
9308. }
9309. public static final BitSet _tokenSet_23 = new BitSet(mk_tokenSet_23());
9310. private static final long[] mk_tokenSet_24() {
9311. long[] data = { -8070450533322321024L, 4501453380673077267L, 16128L, 0L, 0L, 0L};
9312. return data;
9313. }
9314. public static final BitSet _tokenSet_24 = new BitSet(mk_tokenSet_24());
9315. private static final long[] mk_tokenSet_25() {
9316. long[] data = { 1080863912280837728L, -4591419820120997825L, 255L, 0L, 0L, 0L};
9317. return data;
9318. }
9319. public static final BitSet _tokenSet_25 = new BitSet(mk_tokenSet_25());
9320. private static final long[] mk_tokenSet_26() {
9321. long[] data = { -14L, -1048577L, 16383L, 0L, 0L, 0L};
9322. return data;
9323. }
9324. public static final BitSet _tokenSet_26 = new BitSet(mk_tokenSet_26());
9325. private static final long[] mk_tokenSet_27() {
9326. long[] data = { 7344640L, 18014398509482000L, 0L, 0L};
9327. return data;
9328. }
9329. public static final BitSet _tokenSet_27 = new BitSet(mk_tokenSet_27());
9330. private static final long[] mk_tokenSet_28() {
9331. long[] data = { 144115186464330624L, 18014398509481984L, 0L, 0L};
9332. return data;
9333. }
9334. public static final BitSet _tokenSet_28 = new BitSet(mk_tokenSet_28());
9335. private static final long[] mk_tokenSet_29() {
9336. long[] data = { 1080863910568919552L, 18014398509481984L, 0L, 0L};
9337. return data;
9338. }
9339. public static final BitSet _tokenSet_29 = new BitSet(mk_tokenSet_29());
9340. private static final long[] mk_tokenSet_30() {
9341. long[] data = { 1080863911106349664L, 3557280738472624151L, 256L, 0L, 0L, 0L};
9342. return data;
9343. }
9344. public static final BitSet _tokenSet_30 = new BitSet(mk_tokenSet_30());
9345. private static final long[] mk_tokenSet_31() {
9346. long[] data = { 1152921501384777632L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9347. return data;
9348. }
9349. public static final BitSet _tokenSet_31 = new BitSet(mk_tokenSet_31());
9350. private static final long[] mk_tokenSet_32() {
9351. long[] data = { -8133501338408189440L, 4501453380673077275L, 16128L, 0L, 0L, 0L};
9352. return data;
9353. }
9354. public static final BitSet _tokenSet_32 = new BitSet(mk_tokenSet_32());
9355. private static final long[] mk_tokenSet_33() {
9356. long[] data = { 1080863912280836704L, -1053842312821473217L, 511L, 0L, 0L, 0L};
9357. return data;
9358. }
9359. public static final BitSet _tokenSet_33 = new BitSet(mk_tokenSet_33());
9360. private static final long[] mk_tokenSet_34() {
9361. long[] data = { 9006649901580288L, 0L, 0L};
9362. return data;
9363. }
9364. public static final BitSet _tokenSet_34 = new BitSet(mk_tokenSet_34());
9365. private static final long[] mk_tokenSet_35() {
9366. long[] data = { 9223372035780139920L, -4593671619915808749L, 255L, 0L, 0L, 0L};
9367. return data;
9368. }
9369. public static final BitSet _tokenSet_35 = new BitSet(mk_tokenSet_35());
9370. private static final long[] mk_tokenSet_36() {
9371. long[] data = { 9223372035780123536L, -4593671619915808749L, 255L, 0L, 0L, 0L};
9372. return data;
9373. }
9374. public static final BitSet _tokenSet_36 = new BitSet(mk_tokenSet_36());
9375. private static final long[] mk_tokenSet_37() {
9376. long[] data = { 1080863912280836704L, -4591419820120997825L, 255L, 0L, 0L, 0L};
9377. return data;
9378. }
9379. public static final BitSet _tokenSet_37 = new BitSet(mk_tokenSet_37());
9380. private static final long[] mk_tokenSet_38() {
9381. long[] data = { 1080863912280837728L, -4476578029623050177L, 255L, 0L, 0L, 0L};
9382. return data;
9383. }
9384. public static final BitSet _tokenSet_38 = new BitSet(mk_tokenSet_38());
9385. private static final long[] mk_tokenSet_39() {
9386. long[] data = { 1080864392242790944L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9387. return data;
9388. }
9389. public static final BitSet _tokenSet_39 = new BitSet(mk_tokenSet_39());
9390. private static final long[] mk_tokenSet_40() {
9391. long[] data = { 1080863911105790464L, 18014398509482000L, 0L, 0L};
9392. return data;
9393. }
9394. public static final BitSet _tokenSet_40 = new BitSet(mk_tokenSet_40());
9395. private static final long[] mk_tokenSet_41() {
9396. long[] data = { 1080863912280754784L, -1054405279954763721L, 511L, 0L, 0L, 0L};
9397. return data;
9398. }
9399. public static final BitSet _tokenSet_41 = new BitSet(mk_tokenSet_41());
9400. private static final long[] mk_tokenSet_42() {
9401. long[] data = { -8133501338408189440L, 4501453380673077267L, 16128L, 0L, 0L, 0L};
9402. return data;
9403. }
9404. public static final BitSet _tokenSet_42 = new BitSet(mk_tokenSet_42());
9405. private static final long[] mk_tokenSet_43() {
9406. long[] data = { -8070450532247938080L, 4611686018410610751L, 16128L, 0L, 0L, 0L};
9407. return data;
9408. }
9409. public static final BitSet _tokenSet_43 = new BitSet(mk_tokenSet_43());
9410. private static final long[] mk_tokenSet_44() {
9411. long[] data = { -8133501338408123904L, 4501453380673077267L, 16128L, 0L, 0L, 0L};
9412. return data;
9413. }
9414. public static final BitSet _tokenSet_44 = new BitSet(mk_tokenSet_44());
9415. private static final long[] mk_tokenSet_45() {
9416. long[] data = { 1080863911206453760L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9417. return data;
9418. }
9419. public static final BitSet _tokenSet_45 = new BitSet(mk_tokenSet_45());
9420. private static final long[] mk_tokenSet_46() {
9421. long[] data = { 1080864392243350112L, -1054405279954763753L, 511L, 0L, 0L, 0L};
9422. return data;
9423. }
9424. public static final BitSet _tokenSet_46 = new BitSet(mk_tokenSet_46());
9425. private static final long[] mk_tokenSet_47() {
9426. long[] data = { 72057592426438528L, 18014398511579200L, 0L, 0L};
9427. return data;
9428. }
9429. public static final BitSet _tokenSet_47 = new BitSet(mk_tokenSet_47());
9430. private static final long[] mk_tokenSet_48() {
9431. long[] data = { 1152921502459008992L, -4593671619917905865L, 255L, 0L, 0L, 0L};
9432. return data;
9433. }
9434. public static final BitSet _tokenSet_48 = new BitSet(mk_tokenSet_48());
9435. private static final long[] mk_tokenSet_49() {
9436. long[] data = { 1080864393317089888L, -1054405279954763721L, 511L, 0L, 0L, 0L};
9437. return data;
9438. }
9439. public static final BitSet _tokenSet_49 = new BitSet(mk_tokenSet_49());
9440. private static final long[] mk_tokenSet_50() {
9441. long[] data = { 1711833664L, -4593671619917905881L, 255L, 0L, 0L, 0L};
9442. return data;
9443. }
9444. public static final BitSet _tokenSet_50 = new BitSet(mk_tokenSet_50());
9445. private static final long[] mk_tokenSet_51() {
9446. long[] data = { -8070450532247937056L, -108086391071571841L, 16383L, 0L, 0L, 0L};
9447. return data;
9448. }
9449. public static final BitSet _tokenSet_51 = new BitSet(mk_tokenSet_51());
9450. private static final long[] mk_tokenSet_52() {
9451. long[] data = { 524864L, 0L, 0L};
9452. return data;
9453. }
9454. public static final BitSet _tokenSet_52 = new BitSet(mk_tokenSet_52());
9455. private static final long[] mk_tokenSet_53() {
9456. long[] data = { 1152921503532192640L, -4593671619917905869L, 255L, 0L, 0L, 0L};
9457. return data;
9458. }
9459. public static final BitSet _tokenSet_53 = new BitSet(mk_tokenSet_53());
9460. private static final long[] mk_tokenSet_54() {
9461. long[] data = { 638059104L, -4593671619917905913L, 255L, 0L, 0L, 0L};
9462. return data;
9463. }
9464. public static final BitSet _tokenSet_54 = new BitSet(mk_tokenSet_54());
9465. private static final long[] mk_tokenSet_55() {
9466. long[] data = { 9006649901580800L, 18014398509481984L, 0L, 0L};
9467. return data;
9468. }
9469. public static final BitSet _tokenSet_55 = new BitSet(mk_tokenSet_55());
9470. private static final long[] mk_tokenSet_56() {
9471. long[] data = { 9006650539639392L, -4593671619917905913L, 255L, 0L, 0L, 0L};
9472. return data;
9473. }
9474. public static final BitSet _tokenSet_56 = new BitSet(mk_tokenSet_56());
9475. private static final long[] mk_tokenSet_57() {
9476. long[] data = { 1152921501385234400L, -4593671619917905897L, 255L, 0L, 0L, 0L};
9477. return data;
9478. }
9479. public static final BitSet _tokenSet_57 = new BitSet(mk_tokenSet_57());
9480. private static final long[] mk_tokenSet_58() {
9481. long[] data = { -8070450533321763872L, 4611686001230741527L, 16128L, 0L, 0L, 0L};
9482. return data;
9483. }
9484. public static final BitSet _tokenSet_58 = new BitSet(mk_tokenSet_58());
9485. private static final long[] mk_tokenSet_59() {
9486. long[] data = { -8070450533322317952L, 4501453380688804819L, 16128L, 0L, 0L, 0L};
9487. return data;
9488. }
9489. public static final BitSet _tokenSet_59 = new BitSet(mk_tokenSet_59());
9490. private static final long[] mk_tokenSet_60() {
9491. long[] data = { -8070450533321761824L, 4611686018410610711L, 16128L, 0L, 0L, 0L};
9492. return data;
9493. }
9494. public static final BitSet _tokenSet_60 = new BitSet(mk_tokenSet_60());
9495. private static final long[] mk_tokenSet_61() {
9496. long[] data = { -8070450533322301568L, 4501453380688805843L, 16128L, 0L, 0L, 0L};
9497. return data;
9498. }
9499. public static final BitSet _tokenSet_61 = new BitSet(mk_tokenSet_61());
9500. private static final long[] mk_tokenSet_62() {
9501. long[] data = { -1073741838L, -41L, 16383L, 0L, 0L, 0L};
9502. return data;
9503. }
9504. public static final BitSet _tokenSet_62 = new BitSet(mk_tokenSet_62());
9505. private static final long[] mk_tokenSet_63() {
9506. long[] data = { -16400L, -1L, 536870911L, 0L, 0L, 0L};
9507. return data;
9508. }
9509. public static final BitSet _tokenSet_63 = new BitSet(mk_tokenSet_63());
9510. private static final long[] mk_tokenSet_64() {
9511. long[] data = { 96L, 6597069766656L, 0L, 0L};
9512. return data;
9513. }
9514. public static final BitSet _tokenSet_64 = new BitSet(mk_tokenSet_64());
9515. private static final long[] mk_tokenSet_65() {
9516. long[] data = { 0L, 422212465065985L, 0L, 0L};
9517. return data;
9518. }
9519. public static final BitSet _tokenSet_65 = new BitSet(mk_tokenSet_65());
9520. private static final long[] mk_tokenSet_66() {
9521. long[] data = { 9007130937917952L, 18014398509481984L, 0L, 0L};
9522. return data;
9523. }
9524. public static final BitSet _tokenSet_66 = new BitSet(mk_tokenSet_66());
9525. private static final long[] mk_tokenSet_67() {
9526. long[] data = { -8133501338408189440L, 1026820715040473104L, 15872L, 0L, 0L, 0L};
9527. return data;
9528. }
9529. public static final BitSet _tokenSet_67 = new BitSet(mk_tokenSet_67());
9530. private static final long[] mk_tokenSet_68() {
9531. long[] data = { -8133501337333806496L, 4611686018410610751L, 16128L, 0L, 0L, 0L};
9532. return data;
9533. }
9534. public static final BitSet _tokenSet_68 = new BitSet(mk_tokenSet_68());
9535. private static final long[] mk_tokenSet_69() {
9536. long[] data = { 0L, 1153027057723113491L, 0L, 0L};
9537. return data;
9538. }
9539. public static final BitSet _tokenSet_69 = new BitSet(mk_tokenSet_69());
9540. private static final long[] mk_tokenSet_70() {
9541. long[] data = { 0L, 2323857407723175936L, 256L, 0L, 0L, 0L};
9542. return data;
9543. }
9544. public static final BitSet _tokenSet_70 = new BitSet(mk_tokenSet_70());
9545. private static final long[] mk_tokenSet_71() {
9546. long[] data = { -8070450533322321024L, 4501453380673077271L, 16128L, 0L, 0L, 0L};
9547. return data;
9548. }
9549. public static final BitSet _tokenSet_71 = new BitSet(mk_tokenSet_71());
9550. private static final long[] mk_tokenSet_72() {
9551. long[] data = { 9006650438451744L, 18014398509481984L, 0L, 0L};
9552. return data;
9553. }
9554. public static final BitSet _tokenSet_72 = new BitSet(mk_tokenSet_72());
9555. private static final long[] mk_tokenSet_73() {
9556. long[] data = { -8142508125748723200L, 18014398509482000L, 15872L, 0L, 0L, 0L};
9557. return data;
9558. }
9559. public static final BitSet _tokenSet_73 = new BitSet(mk_tokenSet_73());
9560. private static final long[] mk_tokenSet_74() {
9561. long[] data = { 137438953472L, 1008806316530991104L, 0L, 0L};
9562. return data;
9563. }
9564. public static final BitSet _tokenSet_74 = new BitSet(mk_tokenSet_74());
9565. private static final long[] mk_tokenSet_75() {
9566. long[] data = { 72057592963273600L, 18014398509481984L, 0L, 0L};
9567. return data;
9568. }
9569. public static final BitSet _tokenSet_75 = new BitSet(mk_tokenSet_75());
9570. private static final long[] mk_tokenSet_76() {
9571. long[] data = { 1152921504606576608L, -4591419820120997825L, 255L, 0L, 0L, 0L};
9572. return data;
9573. }
9574. public static final BitSet _tokenSet_76 = new BitSet(mk_tokenSet_76());
9575. private static final long[] mk_tokenSet_77() {
9576. long[] data = { 100663808L, -4593671619917905913L, 255L, 0L, 0L, 0L};
9577. return data;
9578. }
9579. public static final BitSet _tokenSet_77 = new BitSet(mk_tokenSet_77());
9580. private static final long[] mk_tokenSet_78() {
9581. long[] data = { -8133500993635759520L, -108086391073669057L, 16383L, 0L, 0L, 0L};
9582. return data;
9583. }
9584. public static final BitSet _tokenSet_78 = new BitSet(mk_tokenSet_78());
9585. private static final long[] mk_tokenSet_79() {
9586. long[] data = { 1611253856L, 2251799796908075L, 0L, 0L};
9587. return data;
9588. }
9589. public static final BitSet _tokenSet_79 = new BitSet(mk_tokenSet_79());
9590.
9591. }
|